一.可变与不可变
可变：值改变，id没有跟着改变，证明就是在改变原值
q=['qwe',123,['qw',123]] print(id(q))=====>>2668034070664 q[0]='QWE' print(q)========>>>>q=['QWE', 123, ['qw', 123]] print(id(q))=====>>2668034070664
不可变：值改变，id也跟着改变,证明是产生了新的值
q =10 print(id(q))=====>>>1368097168 q=11 print(id(q))=====>>>1368097200
二.字符串str
字符串的定义：msg='hello' # msg=str('hello')
数据转换：所有类型都可以被str转换成字符串类型
res=str([1,2,3])
print(res,type(res))
[1, 2, 3] <class 'str'>
内置方法：
1、按索引取值(正向取+反向取) ：只能取
msg='hello' print(msg[0],type(msg[0]))=====>>>h <class 'str'> print(msg[-1])=====>>>o print(msg[-2])=====>>>l
2、切片(顾头不顾尾，步长)
msg='hello world' res=msg[0:3:1] # 0 1 2 print(res)====>>>hel print(msg)====>>>hello world
3、长度len
msg='qwerteryerhrt' print(len(msg))=====>>>13
4、成员运算in和not in:判断一个小字符串是否存在于大字符串中
msg='qwerteryerhrt' print('qwe' in(msg))=====>>>True print('cvb' in(msg) )=====>>>False
5、移除空白strip：用来去除字符串左右两边的字符，不指定去除字符，默认去除空格
实例一：mag=' qwe ' print(mag.strip())=====>>>qwe 实例二：name=input('username:').strip() pwd=input('password:').strip() if name=='qwe' and pwd=='123': print('厉害') else: print('错了') username: qwe password: 123 厉害
6、切分split：针对有规律的字符串，按照某种分隔符列成列表
实例一：info='egon:18:male' res=info.split(':') print(res,type(res)) print(res[0],res[1]) ['egon', '18', 'male'] <class 'list'> egon 18 实例二：qwe='qwe.qd.qwd|faf' print(qwe.split('.')) ['qwe', 'qd', 'qwd|faf'] join的使用 q=['qwe','123','qwwe'] qwe=':'.join(q) print(qwe) qwe:123:qwwe
7、循环
for item in 'hello': print(item) h e l l o
需要掌握
1、strip去两边,lstrip去左边,rstrip去右边
print('*************eron*******'.strip('*'))去两边 print('******egon*******'.lstrip('*'))去左边 print('******egon*******'.rstrip('*'))去右边 eron egon******* ******egon
2、lower字母小写,upper字母大写
print('Abc123'.lower())字母小写 print('Abc123'.upper())字母大写 abc123 ABC123
3、startswith以什么开头,endswith以什么结尾
msg='qwe is asd' print(msg.startswith('q'))判断是否以什么开头 print(msg.endswith('d'))判断以什么结尾 True True
4、format的三种玩法
res='my name is {name} ma age is {age}'.format(name='egon', age=18) print(res) res='my name is {} ma age is {}'.format(18,'egon') print(res) res='my name is {1} ma age is {0}'.format(18,'egon') print(res) my name is egon ma age is 18 my name is 18 ma age is egon my name is egon ma age is 18
5、split切分,rsplit右切分
msg = 'qwe: is: asd' print(msg.split(':',1))切分 print(msg. rsplit(':',1))右切分 ['qwe', ' is: asd'] ['qwe: is', ' asd']
6、replace替换
msg = 'qwe id qwe acsv' print(msg.replace('qwe','asd')) print(msg.replace('qwe','asd',1)) asd id asd acsv asd id qwe acsv
7、isdigit判断是否为纯数字字符串
print('123344'.isdigit()) print('123qqwe123'.isdigit()) True False
了解
1、find,rfind,index,rindex,count
find查找不到会返回一个-1
indxe查找不带会报错
count计数
2、center,ljust,rjust,zfill
填充 .center(50,*)
print('egon').center居中填充
4、captalize首字母大写
swapcase大小写转换
title每个单词字母
5、is数字系列
num1=b'4' #bytes
num2='4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
bytes与阿拉伯数字组成的字符串
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
阿拉伯数字组成的字符串
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
阿拉伯数字中文罗马组成的字符串
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
总结：
存一个值
有序
不可变
列表list：
作用：多个装备，多个爱好，多门课程，多个女朋友等
定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
数据类型转换：但凡能被for循环遍历的数据类型都可以传给list
res=list('hello')=====>>>['h', 'e', 'l', 'l', 'o']
res=list({'a':1,'b':2,'c':3}) =====>>>['a', 'b', 'c']
print(res)
优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以取
l=['a','b','c','d','e'] print(l[0])=====>>>>a print(l[-1])=====>>>e print(id(l))=====>>>1498890049672 l[0]='A' print(l)====>>>['A', 'b', 'c', 'd', 'e'] print(id(l))=====>>>1498890049672 强调强调强调！！！:对于不存在的索引会报错 l[5]='AAAA'=====>>>报错 dic={"k1":111} dic['k2']=2222 print(dic)====>>>{'k1': 111, 'k2': 2222}
2、切片(顾头不顾尾，步长)
l=['a','b','c','d','e'] print(l[1:4])====>>>['b', 'c', 'd'] print(l[::-1])=====>>>['e', 'd', 'c', 'b', 'a']
3、长度
l=['a','b','c','d','e'] print(len(l))=====>>>5
4、成员运算in和not in
l=['a','b','c','d','e'] print('a' in l)====>>>Ture
5、追加
.append()在最后加值 l=['a','b','c','d','e'] l.append('xxx') l.append('yyy') print(l)====>>>['a', 'b', 'c', 'd', 'e', 'xxx', 'yyy'] .insert()在指定索引前面加值 l=['a','b','c','d','e'] l.insert(3,'xxxx') l.insert(0,'yyy') print(l)====>>>['yyy', 'a', 'b', 'c', 'xxxx', 'd', 'e'] .extend l=['aaa','bb',345] l.extend(('1','2','3')) print(l)=====>>>['aaa', 'bb', 345, '1', '2', '3']
6、删除
l=['a','b','c','d','e'] del是一种通用的删除操作，没有返回值 del l[0] print(l)====>>>['b', 'c', 'd', 'e'] dic={'k1':1} del dic['k1'] print(dic)====>>>{} clear是全部清除 l=['aaa','bb',345] l.clear() print(l)=====>>>[] l.remove(指定要删除的那个元素),没有返回值 res=l.remove('b') print(l)====>>>['a','c', 'd', 'e'] print(res)====>>>None l.pop(指定要删除的那个元素的索引),返回刚刚删掉的那个元素 l=['a','b','c','d','e'] l.pop(-1) res=l.pop(1) print(l)====>>>['a', 'c', 'd'] print(res)====>>>b
7、循环
l=['a','b','c','d','e'] for item in l: print(item)
.reverse()反转
l=['aaa','bb',345]
l.reverse()
print(l)=====>>>[345, 'bb', 'aaa']
.sort()只有在类中中所有元素都是同种类型的情况下才能用sort排序
l=['z','d','a']
l.sort()
print(l)====>>>>['a', 'd', 'z']
总结：存多个值，有序，可变
元组
一、定义
t1 = ()
print(t1, type(t1))
参数为for可以循环的对象(可迭代对象)
如何定义一个只有一个值的元组
"Owen"
print(("Owen", ))
print(tuple(['Owen']))
总结：
t = (1, 2, 3)
t = (1, )
常用操作：
索引取值
t = (1, 2, 3, 2, 3, 2) print(t[1]) print(t[-2])
切片
t = (1, 2, 3, 2, 3, 2) print(id(t)) nt = t[:-1:] print(nt, id(nt))
长度len
t = (1, 2, 3, 2, 3, 2) print(len(t))
元组内置方法
print(t.count(2)) # 该数据集合可以存放相同数据
print(t.index(2, 2, 3))
案例
提前拥有一个老师列表，打算开除，如果是校长亲友团，免开 原始列表为list类型 手动输入是否是亲友团，决定是否能开除（） teas = ['Bob', 'Alex'] friends = input("亲友团[0, 1]：") if friends == '1': teas = tuple(teas) => 异常处理 判断teas对象是否是tuple类型 if not isinstance(teas, tuple): # 老师是否是亲友团，不是就开除 teas.clear() for t in teas: print("在职老师：%s" % t)
案例二 元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变 t1 = (1, 2, "abc", True, (1, 2)) # t1永远无法改变 t2 = (1, 2, []) print(t2, type(t2), id(t2), id(t2[2])) t2[2].extend((10, 20)) print(t2, type(t2), id(t2), id(t2[2]))
总结；有序，存多个值，不可变
字典：
特别了解：dict是python中仅存的mapping类型
一、声明
*****
dict的key：可以为所以不可变类型：int float tuple str bool None， 一般就采用字符串
dict的value：可以为所以数据类型
注：key具有唯一性（重复会覆盖旧值），value可以重复
dic = {1: None, None: None, 3.14: None,
True: None, 'abc': None, (1,): None,
None: 12345
}
# 字典无序存储数据，无索引与切片，用key来取值
# 二、增删改查
dic = {}
# 增：key不存在
dic['name'] = 'Mac'
print(dic)
# 改：key已存在
dic['name'] = 'Big Mac'
print(dic)
# 查：
print(dic['name'])
# 删：
del dic['name']
print(dic)
三、get取值 *****
dic = {'a': 10, 'b': 20}
print(dic['c']) # KeyError
res = dic.get('c') # 拥有默认值，None，可以避免错误
print(res)
res = dic.get('d', 'key不存在') # 可以自定义默认值
print(res)
# 增
# 添加的参数字典，与dic可以重复，就是更新值，新key就是新增
dic.update({'a': 100, 'c': 300})
print(dic)
# 删 **
res = dic.pop('c') # 根据key删除指定对象，并返回删除的对象的value
print(res)
# 随机删除，返回值是(key, value)
print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)
# 如何定义一个空字典
# 第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10) # {'a': '', 'b': '', 'c': ''}
案例
添加老师 如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas if 'teas' not in d11: # 成员运算 d11['teas'] = [] d11['teas'].append('Egon') d11['teas'].append('LiuXX') print(d11)
# 原d11中，如果有teas这个key，setdefault相当于什么都没干
# 如果没有，就将第二个参数(默认值)传给teas存放到d11中
d11.setdefault('teas', [])
d11['teas'].append('Egon')
d11['teas'].append('LiuXX')
print(d11)
# 字典的定义：{} | dict()
# 字典的常用操作：增删改查
# 字典的内置方法：
# 字典的循环(迭代)
dic = {'a': 10, 'b': 20, 'c': 30}
# 直接for循环(遍历)字典得到的是key
for k in dic:
print(k, dic[k])
# 能不能只循环值
values = dic.values()
print(values, type(values))
# 存放key的集合
keys = dic.keys()
print(keys, type(keys))
# 存放key-value的键值对关系
k_vs = dic.items()
print(k_vs, type(k_vs))
# dic.values() | dic.keys() | dic.items() 不是原生list，不能直接索引取值，但可以for循环取值
# vs = list(values)
# print(vs[1])
# for v in vs:
# print(v)
for v in values:
print(v)
print()
for k in keys: # 跟直接遍历字典是一样的
print(k)
print()
# ***** 同时遍历k-v
for k, v in dic.items():
print(k, v)
案例
# 案例: 不区分大小写，计算每一个名字出现的次数，记录在字典中 ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon'] # {'owen': 2, 'egon': 3 ...} name_dic = {} for name in ls: # 名字全小写，不用区分大小写 name = name.lower() # 名字是否在字典中存在：存在 - 次数+1 | 不存在 - 添加并设置初值1 if name not in name_dic: # 不存在 name_dic[name] = 1 else: # 存在 name_dic[name] += 1 print(name_dic)
案例
ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon'] name_dic = {} for name in ls: name = name.lower() # name已存在，不管，不存在，初始化指定key：name值为1 name_dic.setdefault(name, 0) name_dic[name] += 1 print(name_dic)
集合：
1、定义与声明
什么是set：
i) 单列数据集合：str，list，tuple，set 双列：dict
ii) 无序存储：无key无index，无法取值
iii) 可变数据类型，内部可以存放任意类型数据，但数据具有唯一性 *****
{}代表空字典，用set()来创建空集合
2、内置方法与使用 - 集合间的运算 （& | ^ - > < ==）
交集 &
res = p_set & l_set print(res) res = p_set.intersection(l_set) print(res) # {'egon'}
并集 |
res = p_set | l_set print(res) res = p_set.union(l_set) print(res) # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}
差集 -
res = p_set - l_set print(res) # {'a', 'b', 'c'} res = l_set.difference(p_set) print(res) # {'x', 'z', 'y'}
对称差集^
res = p_set ^ l_set print(res) res = p_set.symmetric_difference(l_set) print(res) # {'y', 'a', 'b', 'x', 'z', 'c'}
print(p_set)
print(l_set)
p_set.difference_update(l_set) # 将运算结果赋值给调用者
p_set = p_set - l_set
print(p_set) # {'c', 'a', 'b'}
print(l_set) # {'egon', 'z', 'y', 'x'}
# 添加删除操作
s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop() # 随机删除一个ele元素
print(res)
if 'xyz' in s:
s.remove('xyz') # 有ele删除，无ele抛异常
案例
# 3、案例与应用场景 # 选课： class_map = [ ('owen', 'python'), ('egon', 'linux'), ('egon', 'python'), ('liuxx', 'python'), ('liuxx', 'java') ] # 需求： # 1.多少人参加了选课: ['owen', 'egon', 'liuxx'] # 2.都选了哪些课程: ['python', 'linux', 'java'] # 利用逻辑代码去重 names = [] for name, _ in class_map: # 判断列表中是否已存在，不存在才添加 if name not in names: names.append(name) print(names)
# 利用set去重
classes = set()
for _, cless in class_map:
classes.add(cless)
classes = list(classes)
print(classes)