数据类型

一.可变与不可变

可变：值改变，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)