课程视频链接
跟着麦叔学Python：https://b23.tv/WOJgOT
1. list
# 掌握5大金刚，和8字口诀：建=增删改查操=切复
# 1. 5大金刚和各自的特点
# 作业: 1. 写出5大金刚各自的特点 2.记住8字口诀 3.整理知识导图
# 2. immutable和mutable
# score = 99
# s2 = score
# print("old score: ", id(score))
# print("old s2: ", id(s2))
# score = 98
# print("new score: ", id(score))
# print("new s2: ", id(s2))
# name = 'maishu'
# name += ' is dog'
# print(name)
# #name[2] = 'x'
# print(name[2])
# t1 = (1,2,3)
# t1 = (2, 3, 4)
# #t1[0] = 5
# ===8种玩法========
# =========== 1: 创建 = [], list(), range()=======================
#建1=
names = ['zhangsan', 'lisi', 'wangwu']
empty_names = []
print(names)
#建2
names = list() #创建1个空的列表
#可以接受一个iterable可遍历的对象
names = list(range(8))
names = list((1,2,3,4))
names = list('maishu is bad')
# 验证是否可遍历
from collections.abc import Iterable
print(isinstance(345, Iterable)) # False
print(names)
#有序ordered vs 排序sorted：先来后到的自然顺序；一个是按照某种要求排列
# ====== 2: 增添加元素: append, insert, extend, + ==================
names = []
# ---增1 加在末尾
names.append('maishu')
names.append('表叔')
names.append('麦二叔')
names.append(3)
names.append((3,4,5)) #也可增加元组
# ---增2 插入
names.insert(3, 886)
# ---增3 插入的下标超出了长度，就放在最后
names.insert(13, 886) #放在末尾
names.insert(-3, 886) #从后往前=1，=2，=3
# ---增4
bad_guys = ['麦叔', '小麦']
#names.append(bad_guys) #直接把元组作为元素加进去
names.extend(bad_guys) #把里面的元素都加进去
#names += bad_guys
#print(names)
# =========== 3: 删除元素的3种方法: del（消失）, pop（拿出来）, remove（删除指定元素） ===================
#两种删除方法：根据下标，根据内容删除
# ---删1: del 删除指定位置
print(names)
del names[2]
print(names)
# ---删2：pop 删除指定位置并返回
names.pop() # = 默认去掉最后一个
n = names.pop(1) # = 可以指定下标
print(n) # = 会返回pop的值
names.pop(13) # = 如果下标越界，抛出IndexError
# if(len(names)>index): # 可以先判断
print(names)
# ---删3：remove 删除指定元素
print(names)
names.remove('maishu') # = 只会删除第一个符合条件的
print(names)
names.remove('maishu') # = 如果没有符合条件的，就抛出ValueError
if 'maishu' in names: #判断有没有 in
names.remove('maishu')
# ======== 4: 改：修改元素的值============================
# ---改1
print(names)
names[1] = 'biaoshu'
# ---改2 对于超过索引长度的，抛出异常 IndexError
print(names)
names[10] = 'biaoshu'
# list里面保存的是实际对象的地址，修改的过程就是指向了新的地址
# ======== 5. 查：查询元素[], index(), len()======================
# ---查1：查元素，下标从0开始，也可以从-1开始
print(names)
print(names[0])
print(names[-1])
# ---查2: 下标越界，会出现IndexError
print(names[9])
# ---查3: index 查询下标，
print(names.index(886))
print(names.index(8866)) # 如果没有，会抛出ValueError
# ---查4：in, not in 查在不在
if(8866 not in names):
names.append(8866)
else:
names.index(8866)
# ---查5: len() 查长度
print(len(names))
# ========== 6. 操做：loop, +, *, ==, sort, reverse, max, min, sum ===========
# ---操1：loop， 逐个取出元素
for n in names:
print('hello, ', n)
for index, n in enumerate(names): # 逐个取出下标和元素
print('no {} is {}'.format(index + 1, n))
# ---操2：基本运算 +, *, ==
scores = [87, 65, 98, 32]
scores2 = [87, 65, 98, 33]
print(names + scores) # extend是一样的效果
print(scores * 3) # 把所有元素重复3遍
print(scores == scores2) # 判断两个list是否一样，True/False
# ---操3: 排序 ordered（自然排序） sorted（按照顺序） reverse（反转）
scores.reverse() # list.reverse() 逆序，会修改原列表
print(scores)
print(reversed(scores)) # reversed(list) 逆序，不会修改原列表，会返回一个新的
scores.sort() # sort 排序，默认从小到大
print(scores)
scores.sort(reverse=True) # sort 可以指定reverse=True，从大到小
print(scores)
print(sorted(scores, reverse=True)) # sorted(list) 不会修改原列表，会返回一个新的
# sort可以指定key
name_scores = [('zhangsan', 87), ('maishu', 100), ('lisi', 98)]
print(sorted(name_scores, key=lambda n: n[1])) # n 表示list里每个元素，在这里比如是('zhangsan', 87)
# 字符串的比较，是1个个字符比较过去，按照字符顺序，
# 如果前面都一样，长的那个算大 maishu maishub
# ---操4：max, min, sum
print(max(scores))
print(min(scores))
print(sum(scores))
names = ['zhangsan', 'lisi', 'maishu']
print(names)
print(max(names)) # zhangsan
print(min(names)) # lisi
print(sum(names)) # 报错
# ========== 7.切片操作 start:end:step, 其中end不包含在里面 ====================
# print(names)
# print(names[1:6:2])
# ========== 8.复：推导式 Comprehension，map, filter ====================
# print(names)
# names2 = names[:] # 最简单复制，地址不一样
# print(id(names))
# print(id(names2))
nums = list(range(100)) # 0-99
# print(nums)
sq_nums = [n*n for n in nums] # 推导式 Comprehension,返回列表[n*n]
print(sq_nums)
nums_3 = [n*8 for n in nums if n%3==0]
print(nums_3)
print(list(map(lambda n: n*8, nums))) # map, 传入函数
2. tuple
# 掌握5大金刚之tuple，和9字口诀：基建-增删改查操-切复
# 5大金刚包括: list, tuple, set, dict, str
# ======= 1. 基本概念: tuple是一个有序的，不可改的数据结构immutable ================
#l = [5,2,3] #list
t = (5,2,3) #tuple
#优点：1.快 2.安全 3.元组可以被作为dict的key
#python -m timeit '(1,2,3)' #用了9ns左右
#python -m timeit '[1,2,3]' #用了63ns左右
#用的地方：1.参数 2.其他不变的情况
# ======= 2.建 =============================
t1 = (5,8,9)
t2 = tuple([1,2,4]) #把list转换为tuple
t3 = tuple('maishu')
#t4 = tuple(5) iterable可被枚举的才可以被转换
# t5 = (5)
# print(type(t5)) # 只是一个整数
t5 = (5,)
print(type(t5)) #元组
# 增 - 不能
# 删 - 不能
# 改 - 不能
a = (1,3,5)
print(id(a))
a = (8,3,5)
print(id(a)) # 地址不一样，所以不能改，a只是引用，不是元组本身
# ======= 3.查 =============================
print(a[1])
# 操 - 不能
# a.sort()
# a.reverse()
# ======= 4.切（本身相当于新建，所以可以） =============================
b = a[0:-1] #还是用方括号[]
print(b)
# ======= 5.复（复制意义不大） =============================
c = a[:]
c = a
print(c)
3. string
# 掌握5大金刚之string，和9字口诀：基建-增删改查操-切复
# 5大金刚包括: list, tuple, str, set, dict
# ==== 1. 基 - 1. 是一个字符序列(sequence)，2. 基于utf-8编码 3. str ==================
#编码：1. ASCII 2. ISO-9995-1 3.ANSI 4.GBK, GB-2312 4.UTF-8
name = '张三'
print(name)
for n in 'hellomaishu':
print(n)
print(dir(str)) #查看字符串类名
#练习：给一个字符串，找出里面所有的o的字符个数
# ========= 2. 建 ====================================
#2.1 - 简单建 literal 单、双、三引号
zs = '张三'
ls = "李四"
ww = """王五
fsfds
fsdafdas"""
ww2 = '''王五
fsfds
fsdafdas'''
#2.2 转移字符，引号的互相嵌套
zs = '张\t三' # 张 三
ls = 'lisi\'s' # lisi's
ww = "wangwu's" # wangwu's
#2.3 构造方法
score = 98.99
score_str = str(score)
print(type(score_str))
print(str([1,2,3]))
#练习：用一个字符串，打印出"静夜思"这首诗
# ========= 3. 增 ====================================
#3.1 字符串是immutable 不可更改
name = 'zhangsan'
#name[-1] = 'm' # 会报错，不能修改
name2 = 'zhangsan' + 'm' # 创建了一个新的
#3.2 字符串可以被拼接，但任何改变都创建了一个新的字符串
name2 = name[:-1] + 'm'
name3 = name + 'bb'
#3.3 同一个字符串在内存中就只有一份
name4 = name
name5 = 'zhangsan'
# print(id(name))
# print(id(name2))
# print(id(name3))
# print(id(name))
# print(id(name5)) # 1,4,5地址是相同的，可以重用
#4. 删 - 不可能的
#5. 改 - 不可能的
# ========= 6. 查 ====================================
#6.1 可以通过下标来访问一个字符
shame = '打工是不可能的！'
print(shame[-1])
#6.2 子串是否存在 - membership: in, not in 五大金刚都可以用
#identity: is, is not
print(type(shame) is str) # True 判断种类
print('可能X' not in shame) # True
#6.3 开头，结尾
print(shame.startswith('X打工')) # False
print(shame.endswith('！')) # True
#6.4 下标
print(shame.index('可能')) # 4
#作业：定义一个字符串的list，里面保存了很多名字，找出所有姓张的人
# ========= 7. 操 ====================================
# 1.格式化输出
name = 'zhangsan'
greeting = 'hello, ' + name + ', 吃了吗？'
g2 = 'hello, {name}, {name2}, 吃了吗？'
print(g2.format(name='麦叔', name2='张三'))
# print(f'hello, {name}, 喝了吗？') # python3.8
# 2.拆分
names = '张三，李四，王五，二麻子'
for n in names.split('，'):
print(n)
# 3.合并
h = 'hello'
names2 = ['张三', '莉莉丝', '王五']
print(" - ".join(names2)) #分隔符.join()
print(h.join(name)) #把多个h穿插拼接到name字符串里
# 4.查找：出现次数, re正则表达式（没讲）
name = '我是一个小小小小小小小鸟'
print(name.count('小'))
# 5.改变大小写
zhangsan = 'zhangsan is a BAD guy'
print(zhangsan.title()) # Zhangsan Is A BAD Guy 大写每个单词首字母
print(zhangsan.capitalize()) # Zhangsan is a BAD guy 大写整个字符串首字母
print(zhangsan.upper()) # 所有字母都大写
print(zhangsan.lower()) # 所有字母都小写
print(zhangsan.swapcase()) # 交换所有字母大小写
print(zhangsan.islower()) # 判断是否都小写，大写...
# 6.运算
name8 = ' wangba '
print(name8 + name)
print(name8 * 8) # 字符串重复8次
# 7.去空格
name8 = ' wangba '
print(name8.strip()) # 'wangba' 去所有空格
print(name8.lstrip()) # 'wangba ' 只去左边空格
print(name8.rstrip()) # ' wangba' 只去右边空格
# 8.查漏补缺 - 替换
print(name.replace('小','大'))
#练习: 自行研究dir(str)里面的每个方法的作用
# 9.比较：
print('maishu' > 'Maishu3') # True
print('maishu' > 'maishu3') # False
#1个个字符比过去，碰到能决定大小的，就直接返回
#如果一边已经用完了，另一边还有，另一边就赢了
#小写字母大于大写字母；其他顺序查ASCII
#10个字符串练习
#公众号回复：str
#8. 切片
#9. 复制
4. set
# 掌握5大金刚之set，和9字口诀：基建-增删改查操-切复
# 5大金刚包括: list, tuple, str, set/frozenset, dict
# === 1. 基础：不能重复，不分先后，只能加入immutable(不可变)的内容=========================
names1 = {'zs', 'lisi', 'zs'}
print(names1) # {'lisi', 'zs'}
names2 = {'zs', 'lisi', [1,2]} # 报错list可变，TypeError: unhashable type: 'list'
class Person:
def __init__(self, name):
self.name = name
p = Person('wangwu')
names = {'zs', 'lisi', 'zs', p} #这种可变对象可以加
# print(names)
# p.name = 'wangwuwu'
# print(names)
#什么情况下用set，有重复的
# ==== 2. 创建: 大括号，空的代表dict，用set可以空的，也可以转换iterable的对象=============
score = set()
score = {98,89,69,96}
score = set((4,5,6)) # 转换，iterable
print(score)
# ====== 3. 增 ===============================
score.add('zs')
#print(score)
# ====== 4. 删 ====================================
score.remove('zs') #没有会报错
#print(score)
score.discard('ls') #有就移除，没有就什么也不错，但不会报错
#print(score)
score.clear() #清除所有内容
#print(score)
# ====== 5. 改 - 没有顺序 ============================
# ====== 6. 查 in, not in 成员运算符 ====================
score = {98,89,69,96}
print(98 not in score) #True
print(score.pop()) #随机弹出一个
for i in score:
print(i)
# ====== 7. 操作：set集合 - 并，交 =========================
s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
#合并
s3 = s1 | s2
s3 = s1.union(s2)
#交
s3 = s1 & s2
s1.intersection(s2)
#差
s3 = s1 - s2
#不重复的集合
s3 = s1 ^ s2
#比较
print(s1 > s2)
print(s1.issuperset(s2)) #s1 > s2
# ====== 8.切片 不存在，无序 ==================
# ====== 9.复制 copy ===========================
p2 = Person('lisi')
score.add(p2)
print(score)
s4 = score.copy()
print(s4)
# ====== 10. frozenset ========================
s5 = frozenset(s4)
print(s5)
s5.add(88) # 报错，不能增加，冰冻set
5.dict
# 掌握5大金刚之dict，和9字口诀：基建-增删改查操-切复
# 5大金刚包括: list, tuple, str, set/frozenset, dict
# ===== 1.基础 - 键值对，key:value, key必须是immutable不可变的对象 ============================
s = {'zs':66, 'lis':88, 'ms':100}
s = {'zs':{'dd':88, 'xx':99}, 'lis':88, 'ms':100}
# ===== 2.创建 {}, dict(), zip() fromkeys() ====================================================
s = {'zs':66, 'lis':88, 'ms':100} #set也用大括号，直接{}是创建一个空的字典，而不是set
s = dict() #一个空的字典
s = dict([(1,99), (2,88), (3,100)]) #可被转换：包含成对的数据的iterable枚举
print(s)
names = ['za', 'lis', 'ww', 'wb']
scores = [78, 56, 78, 99]
s = dict(zip(names, scores)) #zip是拉链的意思
print(s)
names = ['za', 'lis', 'ww', 'wb']
s3 = dict.fromkeys(names)
print(s3) # {'lis': None, 'wb': None, 'za': None, 'ww': None}
s4 = dict.fromkeys(names, 19)
print(s4) # {'lis': 19, 'wb': 19, 'za': 19, 'ww': 19}
# ===== 3.增 ==================================================
s['ruhua'] = 89
print(s)
s['damei'] = 77
print(s)
# ===== 4.删 del pop, popitem, clear==============================
del s['damei'] #如果删除的key不存在，会抛出KeyError
print(s)
print(s.pop('ruhua')) # 有返回值
print(s)
print(s.popitem()) # 随机删除一个，有返回值
print(s)
s.clear() #全部清除
print(s)
# ===== 5.改 ==================================================
print(s)
s['damei'] = 99
print(s)
# ===== 6.查 [], get, in, not in ==============================
print('ww' in s) #查询
print(s['ww']) #访问
print(s.get('wwx')) #不存在报出None
print(s)
s.setdefault('www', 'google.com') #设默认值，但实际并不存在，除非加进去
print(s['www'])
# ===== 7.操 遍历，items, keys, values, sort ====================
s = {'zs':66, 'lis':88, 'ms':100}
for k in s:
print(k, s[k])
print(list(s.keys())) #取所有key，组成list ['lis', 'ms', 'zs']
print(list(s.values())) #取所有values，组成list [88, 100, 66]
print(list(s.items())) #取所有元组，组成list [('lis', 88), ('ms', 100), ('zs', 66)]
s2 = {k:v for k,v in sorted(s.items())} #按key从小到大排 {'lis': 88, 'ms': 100, 'zs': 66}
print(s2)
# Python小技巧#7：如何给字典Dict按照Value排序？
# ===== 8.切片 fromkeys ==================================================
# ===== 9.复制 copy, update =============================================
s4 = s.copy()
print(s4)
s5 = {'dfd':88, 'xxx':89, 'ww':120}
s = {'zs':66, 'ww':88, 'ms':100}
s.update(s5) # 把s5的更新进s中
print(s) # {'ww': 120, 'xxx': 89, 'ms': 100, 'dfd': 88, 'zs': 66}
附：使用sorted对字典dict排序
1.sorted语法
sorted(iterable, key=None, reverse=False)
参数说明：
iterable – 可迭代对象。
key --主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
**返回：**一个新list对象
① 按键key排序
from operator import itemgetter
dict = {3: 'B', 1: 'A', 2: 'C'}
# 按key升序 .items()取得3个(key,value)
# lambda x: x[0]取(key,value)的key 即(3,1,2)
d1 = sorted(dict.items(), key=lambda x: x[0], reverse=False) # <class 'list'>
# 按key降序 itemgetter类似lambda
d2 = sorted(dict.items(), key=itemgetter(0), reverse=True) # <class 'list'>
# 输出
print(d1, type(d1)) # [(1, 'A'), (2, 'C'), (3, 'B')] <class 'list'>
print(d2, type(d2)) # [(3, 'B'), (2, 'C'), (1, 'A')] <class 'list'>
② 按值value排序
from operator import itemgetter
dict = {3: 'B', 1: 'A', 2: 'C'}
# 按value升序 .items()取得3个(key,value)
# lambda x: x[1]取(key,value)的value 即('B','A','C')
d3 = sorted(dict.items(), key=lambda x: x[1], reverse=False) # <class 'list'>
# 按value降序 itemgetter类似lambda
d4 = sorted(dict.items(), key=itemgetter(1), reverse=True) # <class 'list'>
print(d3, type(d3)) # [(1, 'A'), (3, 'B'), (2, 'C')] <class 'list'>
print(d4, type(d4)) # [(2, 'C'), (3, 'B'), (1, 'A')] <class 'list'>
944
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
