1. python几种数据类型的比较
1. 是否可变。
不可变类型：变量的值可以发生变化，id也变了，相当于创建了一个新的对象，所以一修改值,id就变了，这种类型称之为不可变类型。
可变类型：变量的值可以发生变化，而且 id不会变，所以称之为可变类型。
#数字类型样例
x=10
print (id(x))
输出：1374668752
#修改x的值为100，看看id变了吗？
x=100
print (id(x))
输出：1374671632
可以看到值修改了，id也变了，无法做到修改值，而保持id不变，所以数字类型属于不可变类型。
#字符串样例：
x='yangjianbo'
print(x,id(x))
#修改x的值，两个id比较一下，是否相同。
x='wangyanhe'
print(x,id(x))
输出的结果： 发现字符串的值被修改了，同时它的id也发生了变化，说明是产生了一个新的引用，所以字符串类型也是不可变类型。
# 列表样例：
x = ['yangjianbo', 'wangyanhe', 'gaozhongmin']
print (x, id(x))
# 修改一下某个元素，看看列表x，id是否变化。
x[0] = 'gushuwei'
print (x, id(x))
输出的结果：
['yangjianbo', 'wangyanhe', 'gaozhongmin']
37527688
['gushuwei', 'wangyanhe', 'gaozhongmin']
37527688
结论：修改列表中的某个元素，不会影响整个列表的id，所以列表属于可变类型。 # 元组样例：
x = ('yangjianbo', 'wangyanhe', 'gaozhongmin')
print (x, id(x))
x[0] = 'gushuwei'
print (x, id(x))
输出结果：直接报错，因为元组只可读，不能写。
结论：元组是不可变类型。 # 字典
x = {'name': 'yangjianbo', 'age': 10, 'bumen': 'xitongbu'}
print (x, id(x))
x['name'] = 'wangyanhe'
print (x, id(x))
输出结果：
{'name': 'yangjianbo', 'age': 10, 'bumen': 'xitongbu'}
31218928
{'name': 'wangyanhe', 'age': 10, 'bumen': 'xitongbu'}
31218928
结论：字典的值可以修改，而且id不会发生变化，所以字典属于可变类型。
2. 有序或无序。
有序和无序，数据类型能否按照索引的方式，读出数据。
#数字类型
x=10
print (x[0])
结论：报错了，数字类型，无法使用索引读出，它不是一个有序的数据类型。
#字符串
x='aabbcc4455'
print (x[9])
结论：字符串可以通过索引读取字符串中的字符，字符串是有序的数据类型。
#列表
x=['yangjianbo','wangyanhe','gaozhongmin']
print (x[0])
结论：列表读取某个元素，必须指定元素的索引，所以列表是有序的数据类型。
#元组
x=('yangjianbo','wangyanhe','gaozhongmin')
print (x[0])
结论：元组读取某个元素，必须指定元素的索引，所以元组是有序的数据类型。
#字典
x={'name':'yangjianbo','age':10,'bumen':'xitongbu'}
print (x['name'])
结论：字典读取其中的某个值，必须指定键名称，不能按照索引进行读取。所以字典不是有序的数据类型。
3. 是否可读写。
除了元组不可写，其他类型都支持读写。
4. 存一个值还是多个值。
数字类型只有一个值，
字符串也只有一个值
列表多个值
元组多个值
字典多个值
2. 数字类型的一些功能
两个变量交换数值。
x=10
y=20
print (x,id(x))
print (y,id(y))
x,y=y,x
print (x,id(x))
print (y,id(y))
输出结果：
10 8791457912128
20 8791457912448
20 8791457912448
10 8791457912128 将多个变量引用到一个值上。
x=y=z=100
print (x,y,z,id(x),id(y),id(z))
3. 字符串的一些功能
查看字符串长度
x='aaa11111'
print (len(x))
字符串切片
x='abc12345ABC'
print (x[1:9:3])
第一个数字1表示从索引1开始，
第二个数字9表示到第9-1索引结束
第三个数字3表示步长，从索引1开始数，三步一个。 输出的结果：b25
成员运算符
x='abc12345ABC'
print ('A' in x)
print ('B' not in x)
输出的结果 True False
移除空格
使用字符串的函数strip() lstrip() rstrip()
strip()默认移除的是空白符，\t \r \n.
name = " yangjianbo"
print (name)
name=name.strip()
print (name)
输出的yangjianbo，没有前面的空白。
name = "yangjianbo*****"
name=name.strip('*')
print (name)
输出的结果：忽略*号字符。
name = "yangjianbo*****"
name=name.strip('an')
print (name)
输出的结果：我要忽略an，这个an字符在整个字符串的中间部分，而不是两头，结果输出的结果依然是原来的值 结论：中间的字符不能被忽略，只能忽略头和尾的字符。
分割
x='I am yang jian bo !'
print (x.split(' ',1))
输出结果：split函数第一个参数是以哪个分隔符进行切割（默认为空格，\r \n \t），第二个参数是要求分成几份。
也可以只指定第一个参数，会以最大的份数分割，分割成列表数据类型。
以字符开头
x='I am yang jian bo !'
print (x.startswith('yang',5,11))
输出的结果： True
startswith函数的意思是：是不是以指定的字符串开头的，第一个参数是你要查找的字符串，第二个参数是你要从哪个索引开始查，第三个参数是指你到哪个索引结束。返回的值是布尔值。正确则为true,则为false.
以字符结尾
x='I am yang jian bo !'
print (x.endswith('yang',5,11))
输出结果： False
endswith函数是用来检测是不是以指定的字符串结尾的，参数设置与startswith相同，返回值也是一样的。
替换
x='I am yang jian bo !'
print (x.replace('a','b',2))
输出的结果：I bm ybng jian bo !
replace函数用来替换指定的字符串，第一个参数指定旧的字符串，第二个参数指定新的字符串，第三个参数指定要替换几个字符串。
大写改小写
x='I am yang jian bo !'
print (x.upper())
输出的结果：I AM YANG JIAN BO !
将字符串中的小写字母改为大写字母。
将结果改为小写
x='I am yang jian bo !'
print (x.lower())
输出的结果：i am yang jian bo !
将字符串中的大写字母改为小写字母。
查找字符对应的索引
x='I am yang jian bo !'
print (x.index("a"))
输出的结果：将第一个匹配的字符串对应的索引打印出。
判断字符串是不是只包含数字
password=input("输入密码：")
if not password.isdigit() :
print ("请输入正确密码，只包含数字!")
else:
print ("登录成功！")
输出的结果：如果输入字母，会报错。
同理is类型的函数还有
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
如果 string 只包含十进制数字则返回 True 否则返回 False.
字符串的join函数
l=['True','or','False']
s=' '
res=s.join(l)
print(res,type(res))
结果:
"D:\Program Files\Python36\python.exe" C:/Users/yangjianbo/PycharmProjects/untitled/第三课函数基础/join函数.py
True or False <class 'str'>
结论：
Python join() 方法用于将列表中的元素以指定的字符连接生成一个新的字符串。
4. 列表
长度
x=['yangjianbo','wangyanhe','gaozhongmin']
print (len(x))
输出结果： 3
切片
x=['yangjianbo','wangyanhe','gaozhongmin']
print (x[1:3])
输出的结果：['wangyanhe', 'gaozhongmin']
切片的顺序其实跟步长有关系，默认步长为1。
从列表索引1开始，到索引3（不包括）结束。 x=['yangjianbo','wangyanhe','gaozhongmin','gushuwei','liudehua','zhangxueyou']
print (x[-3:-1])
输出结果：['gushuwei', 'liudehua']
从列表索引-1开始(不包括)，到索引-3（包括）结束。
翻转
num=[1,2,3,4,5,6,7]
print (num[::-1])
输出结果：[7, 6, 5, 4, 3, 2, 1]
追加
x=['yangjianbo','wangyanhe','gaozhongmin']
x.append('gushuwei')
print (x)
输出的结果：['yangjianbo', 'wangyanhe', 'gaozhongmin', 'gushuwei']
append()函数在列表的最后追加一个新的元素，append()函数不会有返回值。返回None
删除
x=['yangjianbo','wangyanhe','gaozhongmin']
print (x.pop(2))
输出结果：gaozhongmin
pop()函数的参数是索引
pop删除并返回值
x=['yangjianbo','wangyanhe','gaozhongmin','wang','gaozhongmin']
print (x.remove('gaozhongmin'))
print (x)
输出结果：None
['yangjianbo', 'wangyanhe', 'wang', 'gaozhongmin']
remove()函数的参数是元素的值
remove删除元素，但是不会返回值
更新
x=['yangjianbo','wangyanhe','gaozhongmin']
x[1]='zhangxueyou'
print (x)
输出结果：['yangjianbo', 'zhangxueyou', 'gaozhongmin']
排序 练习题 1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data=['alex',49,[1900,3,18]]
name=data[0]
age=data[1]
birth=data[2]
print (name,age,birth[0],birth[1],birth[2])
输出结果：alex 49 1900 3 18
2. 用列表模拟队列
队列要求就是：先进先出，后进后出。
num=[] 先创建一个空的列表
num.append(1) 往空的列表追加一个1
num.append(2) 再追加一个2
num.append(3) 再追加一个3
num.append(4) 再追加一个4
num.pop(0) 删除第一个元素
num.pop(0) 删除第一个元素 num.pop(0) 删除第一个元素
num.pop(0) 删除第一个元素
print (num)
以上就相当于先进先出。
3. 用列表模拟堆栈
先进后出，后进先出
num=[]
num.append(1)
num.append(2)
num.append(3)
num.append(4)
num.pop(-1)
num.pop(-1)
num.pop(-1)
num.pop(-1)
print (num)
4. 有如下列表，请按照年龄排序（涉及到匿名函数）
l=[
{'name':'alex','age':84},
{'name':'oldboy','age':73},
{'name':'egon','age':18},
]
五. 元组
长度
读取
切片
成员运算in或者not in
元组与列表相同 六. 字典
键值要成对。
键必须为不可变类型，所以键不能为列表。值可以为任意类型。 读取
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
print (xitongbu['name'])
输出的结果：yangjianbo
字典查询，需要按照键查找，不能按照索引，因为字典是无序的。
长度
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
print (len(xitongbu))
输出的结果：3
显示字典有几对键值。
成员in not in
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
print ('name' in xitongbu)
输出的结果：True
字典只能查看键是不是成员，而不能看值。
添加键值
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu)
输出结果：{'name': 'yangjianbo', 'age': 30, 'zhiwei': 'gongchengshi', 'gongzi': 20000}
删除某个键
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
del xitongbu['zhiwei']
print (xitongbu)
输出结果：{'name': 'yangjianbo', 'age': 30, 'gongzi': 20000}
删除整个字典
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
del xitongbu
print (xitongbu)
输出的结果：NameError: name 'xitongbu' is not defined
删除xitongbu,变量都不存在了。
清空整个字典
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
xitongbu.clear()
print (xitongbu)
输出的结果：{}
字典被清空，但是变量还在。
字典常用的方法
清空 dic.clear() 删除键并返回值 dic.pop()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.pop('gongzi'))
print (xitongbu)
输出的结果：{'name': 'yangjianbo', 'age': 30, 'zhiwei': 'gongchengshi'}
使用pop函数删除键，会有返回值。
打印键 dic.keys()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.keys())
print ('name' in xitongbu.keys())
输出的结果：字典的所有键会被打印出
打印值 dic.values()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.values(),type(xitongbu.values()))
print ('gongchengshi' in xitongbu.values())
输出的结果：打印出的结果是字典所有的值。 打印键和值 dic.items()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.items(),type(xitongbu.items()))
输出的结果：打印出字典的键和值。
七. 集合
特点：与字典一样采用大括号，但是只有值，没有键。 集合不支持索引。
长度 len()函数
name={'yangjianbo','wangyanhe','gaozhongmin'}
print (len(name))
成员in not in
name={'yangjianbo','wangyanhe','gaozhongmin'}
if 'yangjian' in name:
print ("you are right!")
else:
print("you are wrong!")
交集 使用符号&
name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name1&name2)
输出的结果：是两个集合的相同的部分。
差集 -
name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name1-name2,type(name1-name2))
输出的结果：谁在前面，就以谁为标准，减去相同的，剩下的就是差集。
name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name2-name1,type(name2-name1))
输出的结果：顺序不同，最后得到的差集也不同。
并集 |
name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name1|name2)
输出的结果：两个集合合并后的结果，合并后还是一个集合。
对称差集 ^
name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name2^name1,type(name2^name1))
输出的结果：{'gaozhongmin', 'wangyanhe', 'zhoujianping', 'liushuang'} <class 'set'>
八. for循环
for循环用来遍历string和list，字典的内容。
遍历字符串
name='yangjianbo'
for i in name:
print (i)
输出的结果：单个的字符.
打印出字符的索引 遍历列表
name=['yangjianbo','wangyanhe','gaozhongmin']
for i in name:
print (i)
输出的结果：输出各个元素。
打印出列表的元素。 遍历列表：
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
输出结果：当循环完成时候，才会执行else后面的语句，但是这个for循环不会执行else语句，因为执行被break.
九. 身份运算符
is is not
is与==的不同：is查看对象是否来自一个引用，==比较的是值。
十.字码编符
计算机只认识0和1
把字符翻译成数字。这个翻译过程就叫做字符编码。
最开始的字符编码表ASCII，一个bytes表示一个字符，一个bytes有8位，可以表示256个字符。ASCII最高一位保留，最初只用了127个字符。后来拉丁文也进入了ASCII编码。
但是ASCII无法显示中文，于是中国人就发明了GB2312,用两个字节表示中文，也就产生了2的16次方-1个，表示中文。
日本人发明了自己的字符编码，韩国人也有自己的字符编码，但是各国的字符编码都不能相互读出来，所以产生了乱码。
于是在这种情况下，为了统一各国的字符编码，就产生了一种unicode，用两个字节表示所有的字符，不管是英文，中文，日文，韩文，都用两个字节来表示。unicode这种方式，
会导致英文字符，前8位的浪费。
所以又产生了UTF-8，可变长的字符编码，对英文字符用一个字节，对中文字符用3个字节。
unicode:简单粗暴，执行速度快，但是浪费空间
UTF-8:执行速度慢，因为它得检查字符，节约空间。
当内存从硬盘读取数据的时候，优先考虑的是速度，所以内存内部使用的是unicode.当UTF-8翻译成unicode的时候，叫做：decode，过程叫做解码。
当内存保存数据到硬盘的时候，优先考虑的是空间，所以硬盘使用的是UTF-8或者其他国家的编码。当unicode翻译成UTF-8的时候，叫做：encode，过程叫做编码。
存的时候用什么编码，读的时候就用什么编码。 读文件的阶段：
python2解释器默认编码是ASCII
python3解释器默认编码是UTF-8
所以要在python文件开头，加#coding:指定文件保存时候的编码。 执行文件的阶段:
执行python代码的时候，python3的字符串是unicode编码.
x='杨建'
print(type(x.encode('gbk')))
只有unicode才可以encode为其他编码。
执行python代码的时候，python2的字符串是bytes编码.所以在python2的字符串前面加u.
x=u'你好' 这样就成为了unicode编码。 windows终端编码gbk
linux终端编码utf-8 最后文件练习题：
#求出所购买的东西的价格总数。 count=[]
with open('a.txt','r') as read_f:
for line in read_f:
line=line.split(' ')
line_count=int(line[1])*int(line[2])
count.append(line_count)
if len(count)==5:
print(sum(count))
作业一：
#作业一: 三级菜单
#要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序
低级版本：
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}
while True:
for key1 in menu:
print(key1)
choice1=input('选择>>').strip()
if choice1=='b':break
if not choice1 or choice1 not in menu:continue
while True:
for key2 in menu[choice1]:
print(key2)
choice2=input('选择>>').strip()
if choice2=='b':break
if not choice2 or choice2 not in menu[choice1]:continue
while True:
for key3 in menu[choice1][choice2]:
print(key3)
choice3=input('选择>>').strip()
if choice3=='b':break
if not choice3 or choice3 not in menu[choice1][choice2]:continue
while True:
for key4 in menu[choice1][choice2][choice3]:
print(key4)
choice4=input('选择>>').strip()
if choice4=='b':break
升级版本：
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}
level=[]
while True:
for key in menu:
print(key)
choice=input('选择>>').strip()
if choice=='b':
if len(level)==0:break
menu=level[-1]
level.pop()
if not choice:continue
if choice not in menu:continue
level.append(menu)
menu=menu[choice]
作业二最终版：
#作业二：请闭眼写出购物车程序
#需求:
用户名和密码存放于文件中，格式为：egon|egon123
启动程序后，先登录，登录成功则让用户输入工资,然后打印商品列表，失败则重新登录，超过三次则退出程序
允许用户根据商品编号购买商品
用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
可随时退出，退出时，打印已购买商品和余额 最终代码：
dic={
1:['apple',200],
2:['tesla',2000000],
3:['lenovo',3000]
}
userinfo={'yangjianbo':['123456',20000],'wangyanhe':['abcd',200]}
count=0
while True:
username = input('用户名>>').strip()
if count==3:
print("用户名输入已经3次")
break
elif not username in userinfo:
print("用户名错误")
elif username in userinfo:
password = input('密码>>').strip()
if password!=userinfo[username][0]:
print('用户名密码不正确！')
count+=1
elif password==userinfo[username][0]:
print('登陆成功！')
while True:
choice_dic={'购物车':1,'查看余额':2,'退出':3}
print(choice_dic)
choice_type=int(input('请输入您的选择：'))
if choice_type==choice_dic['购物车']:
print(dic)
while True:
choice = input('请输入您要购买的物品的编号>>').strip()
if choice=='exit':
exit()
elif not choice.isdigit(): continue
for id, product in dic.items():
choice = int(choice)
if choice == id:
print('确认要购买%s吗？' % product[0])
quren = input('是否购买 y/n:').strip()
if quren in ('yes' or 'y'):
userinfo[username][1] = int(userinfo[username][1])
if userinfo[username][1] > product[1]:
userinfo[username][1] = userinfo[username][1] - product[1]
print('您已经购买了%s! 您的余额还有%s元!' % (product[0],userinfo[username][1]))
else:
print('您的余额不足，请尽快充值！')
elif quren in ('no' or 'n'):
break
elif choice_type==choice_dic['查看余额']:
print('您的余额是%s元' % userinfo[username][1])
elif choice_type==choice_dic['退出']:
exit()