第1章 数据类型：
1.1可变or不可变类型（变量值）：
变量的三个特点：id/type/value
可变类型：值改变，但id不变，证明就是在改变原值
不可变类型：值改变，id也跟着变了，证明申请了新的内存空间来存新值，根本没有改变量值
Ø 证明浮点型是不可变类型
x=1.1
print(id(x))
x=1.2
print(id(x))
#4344525016
#4344525136
Ø 证明int是不可变类型：
x=10
print(id(x))
x=11
print(id(x))
#4457767232
#4457767264
Ø 证明列表是可变类型：
h=['a','b','c']
print(id(h))
h[0]='J'#修改列表中的某一个值
print(id(h))
#4498034504
#4498034504
Ø 证明字典是可变类型：
h={'x':1,'y':2}
print(id(h))
h['x']=10
print(id(h))
#4363789224
#4363789224
1.2什么是数据？
X=10 10就是我们要存储的数据
1.3为何数据要分不同的数据类型？
数据是用来表示状态的，不同的状态就应该用不同的数据去表示
1.4数据类型：
1.4.1数字（×××，长整型，浮点型，复数）
定义×××方式：
x=int(10)
print(type(x))
定义浮点型方式：
x=float(1.22)
print(type(x))
1.4.2字符串str
作用：名字，性别，国籍，地址等描述信息
定义：在单引号、双引号、三引号内，由一串字符组成
x=str('jiang')
print(type(x))
str类型可以将任意类型转成字符串类型：
x=str({'a':1})
print(x,type(x))
name='*egon**'
print(name.strip('*'))取*号中间的部分
print(name.lstrip('*'))取*号左边的部分
print(name.rstrip('*'))取*号右边的部分
name='egon'
print(name.lower())#变成小写
print(name.upper())#变成大写
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串
#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())
求字符串的长度：
j='asd'
print(len(j))
成员运算in和not in ：判断一个子字符换是否存在于一个大字符串中
name='my name is jiang,jiang is man'
print('jiang' in name)
移除字符串左右两边的空白：
name=' hello '
res=name.strip(' ')
print(res)
name='***hello***'
res=name.strip('*')
print(res)
切分split：
info='root:x:0:0::/root:/bin/bash'
res=info.split(':')
print(res[0])
练习：
移除name变量对应的值两边的空格，并输出处理结果
name=' aleX'
a=name.strip()
print(a)
判断name变量对应的值是否以“al”开头，并输出结果
name=' aaleX'
if name.startswith(al):
print(name)
else:
print('no')
判断name变量对应的值是否以“x”结尾，并输出结果
name=' aaleX'
if name.endswith(name):
print(name)
else:
print('no')
将name变量对应的值中的“1”替换为“p”，并输出结果
name=' aleX'
print(name.replace('l','p'))
将name变量对应的值根据“l”分隔，并输出结果
name=' aleX'
print(name.split('l'))
将name变量对应的值变大写，然后输出结果
name=' aleX'
print(name.upper())
将name变量对应的值变小写，然后输出结果
name=' aleX'
print(name.lower())
请输出name变量的值的第2个字符
name=' aleX'
print(name[1])
请输出name变量对应的值中“e”所在索引的位置
name=' aleX'
print(name.index('e'))
获取子序列，去掉最后一个字符
name=' aleX'
a=name[:-1]
print(a)
1.4.3列表
作用：多个装备，多个爱好，多门课程等
定义：[]内可以有多个任意类型的值，逗号分隔
name=['a','b','c']
print(name,type(name))
按照索引取值改值：
name=['a','b','c']
print(name)
name[-1]='A'
print(name[-1])
增加列表的元素：
name=['a','b','c']
name.append('jiang')
print(name)
删除列表的元素
name=['a','b','c']
del name[0]
print(name)
name.remove('b')
print(name)
切片：
name=['a','b','c']
print(name[0:2])
计算长度（就是计算列表中元素的个数）：
name=['a','b','c']
print(len(name))
成员运算in和not in：
name=['a','b','c']
print('jiang' in name)
计算个数：
name=['a','b','c','a']
print(name.count('a'))
查看索引，默认找到第一个就返回找不到则报错：
name=['a','b','c','a']
print(name.index('a'))
排序：
name=[11,-3,0,99,88]
name.sort()
print(name)
反转：
name=[11,-3,0,99,88]
name.reverse()
print(name)
name=[11,-3,0,99,88]
res=name[::-1]
print(res)
1.4.4元组
作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要用来读
定义：与列表类型比，只不过[]换成（）
1.4.5字典
作用：存多个值，key-value存取，取值速度快
定义：key必须是不可变类型，value可以是任意类型
1.4.6集合
作用：去重，关系运算
定义：可变类型是不可hash类型，不可变类型是可hash类型
定义集合：在{}内用逗号隔开
x={1,3,5,6,7,1,1}
print(x)
如何造一个空集合：
x={}
print(type(x))
s=set()
print(type(s))
x={}
print(type(x))
s=set()
print(type(s))
长度计算
s={1,2,2,3}
print(len(s))
成员运算
s={'egon','alex','oldboy'}
print('jiang' in s)
关系运算：
python_stu=['egon','alex','kevin','王大炮','李二丫']
linux_stu=['张铁蛋','刘铜蛋','赵金蛋','alex','oldboy','kevin']
res=[]
for stu1 in python_stu:
if stu1 in linux_stu:
res.append(stu1)
print(res)
交集
python_stu={'egon','alex','kevin','王大炮','李二丫'}
linux_stu={'张铁蛋','刘铜蛋','赵金蛋','alex','oldboy','kevin'}
print(python_stu& linux_stu)
print(python_stu.intersection(linux_stu))
合集
print(python_stu | linux_stu)
print(python_stu.union(linux_stu))
差集
print(python_stu - linux_stu)
print(python_stu.difference(linux_stu))
对称差集
print((python_stu - linux_stu) | (linux_stu - python_stu))
print(python_stu ^ linux_stu)
print(python_stu.symmetric_difference(linux_stu))
==
x={1,2,3}
y={1,3,2}
print(x== y)
父集（>= ）
s={1,2,3,4}
y={1,2,3}
print(s>= y)
print(s.issuperset(y))
子集(<=)
s={1,2,3}
y={1,2,3,4}
print(s<= y)
print(s.issubset(y))
1.4.7数据类型的总结：
按存储空间的占用从低到高
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，需要处理数据的增删改
练习
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
print(pythons| linuxs)#求出所有报名学生名字集合
print(pythons& linuxs)#求出同时报这两个课程的集合
print(pythons- linuxs)#求出只报了python的学生
print(pythons^ linuxs)#没有同事报两个课程的集合
去重：
1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
l=['a','b',1,'a','a']
print(set(l))
2.在上题的基础上，保存列表原来的顺序
l=['a','b',1,'a','a']
ll=[]
for iin l:
if i not in ll:
ll.append(i)
print(ll)
利用集合
l=['a','b',1,'a','a']
ll=[]
s=set()
for iin l:
if i not in s:
s.add(i)
ll.append(i)
print(ll)
3.去除文件中重复的行，肯定要保持文件内容的顺序不变
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
open('.db.txt.swap','w',encoding='utf-8') as write_f:
s=set()
for line in read_f:
if line not in s:
s.add(line)
write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')
4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'egon','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'egon','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
s=set()
ll=[]
for i in l:
val=(i['name'],i['age'],i['sex'])
if val not in s:
s.add(val)
ll.append(i)
print(ll)