一、有序无序+可变不可变
#1、有序：但凡有索引的数据都是有序的
#2、可变不可变
#可变类型：在值变了的情况下，id不变，证明在改原值
#不可变类型：在值变了的情况下，id也跟着变，证明不是在改原值二、数字类型
# 1 用途：记录年龄、等级、号码
# int
# 2 定义方式
age=18 #age=int(18)
# print(type(age))
# int('abadf') #报错
# int('10.1') #报错
# int('101') #int只能将字符串中包含纯数字转成整型
三：# 进制转换（了解**）
# 其他进制转成十进制
# 二进制：0，1
# 10 #1*(2**1) + 0*(2**0)
# # 十进制：0-9
# 371 #3*(10**2) + 7*(10**1) + 1*(10**0)
# # 八进制：0-7
# 371 #3*(8**2) + 7*(8**1) + 1*(8**0)
# # 十六进制：0-9 A-F
# 371 #3*(16**2) + 7*(16**1) + 1*(8**0)
# 十进制转成其他进制
# print(bin(12))
# print(oct(12)) #14 =>1*(8**1) + 4*(8**0)
# print(hex(16))
常用操作+内置的方法
四、该类型总结
# 1 存一个值
#
# 2 不可变
# x=10
# print(id(x))
# x=11
# print(id(x))
五、基本使用：float
# 1 用途：记录身高、体重、薪资
#
# 2 定义方式
# salary=3.1 #salary=float(3.1)
# res=float('3.3')
# print(type(res))
# 3 常用操作+内置的方法
六、该类型总结
# 1 存一个值
#
# 2 不可变
x=10.3
print(id(x))
x=10.4
print(id(x))
七、列表的的基本使用
# 1 用途：存放多个值，可以根据索引存取值
# 2 定义方式：在[]内用逗号分割开多个任意类型的值
li=['hello','word',1,2,3]
print(li[1])
------------------------------------
l2=list({'x':1,'y':2,'z':3})
print(l2)# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
li=['hello','word',1,2,3]
查：
print(li[1])
word
改：
li[2]='s_jun'
print(li)
['hello', 'word', 's_jun', 2, 3]#2、切片(顾头不顾尾，步长)
li=['hello','word',1,2,3]
print(li[0:4])
print(li[0:5:2])
print(li[::-1])#3、长度
li=['hello','word',1,2,3]
print(len(li))
5#4、成员运算in和not in
li=['hello','word',1,2,3]
print('hello' in li)
print('apple' not in li)
True
True#5、追加
li=['hello','word',1,2,3]
li.append('xx1')
li.extend(['a','b','c'])
print(li)
['hello', 'word', 1, 2, 3, 'xx1', 'a', 'b', 'c']#6、往指定索引前插入值
li=['hello','word',1,2,3]
li.insert(1,'a')
print(li)
['hello', 'a', 'word', 1, 2, 3]#7、删除
li=['hello','word',1,2,3]
# 单纯的删除值：
# 方式1：
li=['hello','word',1,2,3]
del li[3]
print(li)
['hello', 'word', 1, 3]
# 按关键字删除
# 方式2：
li=['hello','word',1,2,3]
li.remove("hello")
print(li)
['word', 1, 2, 3]# 从列表中拿走一个值
# 按照索引删除值(默认是从末尾删除)，返回删除的那个值
li=['hello','word',1,2,3]
li.pop(-2)
print(li)
['hello', 'word', 1, 3]#8、循环
li=['hello','word',1]
for i in li:
print(i)
hello
word
1# 需要掌握的操作
# 计数
li=['hello','word',1,2,3,'hello']
print(li.count('hello'))
2
# 按关键字查找位置
li=['hello','word',1,2,3,'hello']
print(li.index('word'))
1
# 清除列表里面的值
li=['hello','word',1,2,3,'hello']
print(li.clear())
None
----------------------------------------
l=[]
items=['a','b','c']
for item in items:
l.append(item)
l.extend(items)
print(l)反转排序
li=['hello','word',1,2,3,'hello']
li.reverse() #[::-1] 反向排序
print(li)#从大到小排序
nums=[3,-1,9,8,11]
nums.sort(reverse=True)
print(nums)
[11, 9, 8, 3, -1]# 从小到大排序
items=[3,-1,9,8,11]
items.sort()
print(items)
[-1, 3, 8, 9, 11]八、该类型总结
# 1 存多个值
# 2 有序
# 3 可变
l=['a','b','c']
print(id(l))
l.append('d')
print(id(l))
---------------------------
2062093871240
2062093871240# 队列：先进先出
l=[]
# 入队
l.append('first')
l.append('second')
l.append('third')
print(l)
-----------------------
['first', 'second', 'third']# 出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))# 堆栈：先进后出
l=[]
# 入栈
l.append('first')
l.append('second')
l.append('third')
print(l)
# 出栈
print(l.pop())
print(l.pop())
print(l.pop())
------------------------------
['first', 'second', 'third']
third
second
first练习作业：
默写99乘法标
金字塔
必做:
1.昨日选做题 博客中有 http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label3
2.要求用户输入五个数字存储到列表中, 然后提供三个功能 2.1 打印最大值 2.2 打印最小值 2.3 打印平均数
3.交换两个列表中的元素,(两个列表元素个数相同)
4.有以下列表
["python","java","C++","PHP","HTML","python","C++","Ruby"]
编写代码去除列表中重复的元素
5.查看提供的(待处理文本.txt)文件 编写代码取出所有图片的网址 住 不需要直接读取文件 把内容复制到代码找中定义为变量即可
6.有如下字符串("language,is,perfect,hello,i am jack,python")
编写代码 将其修改为"hello i am jack python is perfect language" 字符串
选做
7.有如下列表
[5,2,1,4,3]
编写代码实现从大到小排序 (百度搜索冒泡排序)
8.简单购物车 博客题http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label81、
# 2.要求用户输入五个数字存储到列表中, 然后提供三个功能
# 2.1 打印最大值
# 2.2 打印最小值
# 2.3 打印平均数 只能输入整数
my_list = []
while True:
# 输入数字
text = input("请输入数字：")
if text.isdigit():
num = int(text)
my_list.append(num)
# 当长度达到5 就结束循环
if len(my_list) == 5:
break
else:
print("请输入整数")
print(my_list)
# 求最大值 每次拿出一个值与当前的最大值进行比较
# 先假设第一个元素就是最大值
max_num = my_list[0]
# 先假设第一个元素就是最小值
min_num = my_list[0]
# 搞一个变量保存所有数的和
sum_num = 0
for i in my_list:
if i > max_num:
max_num = i
if i < min_num:
min_num = i
sum_num += i
select = input("""
1.最大值
2.最小值
3.平均值
""")
while True :
if select == "q":
break
if select == "1":
print(max_num)
break
elif select == "2":
print(min_num)
break
elif select == "3":
print(sum_num / 5)
break
else:
print("看不懂中文吗？ ")2、
# 3.交换两个列表中的元素,(两个列表元素个数相同)
my_list1 = [1,2,3,4,5]
my_list2 = [5,4,3,2,1]
# my_list1, my_list2 = my_list2, my_list1
# print(my_list1)
i = 0
while i < len(my_list1):
temp = my_list1[i]
my_list1[i] = my_list2[i]
my_list2[i] = temp
i += 1
print(my_list1)
print(my_list2)
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]3、
"""
4.有以下列表
["python","java","C++","PHP","HTML","python","C++","Ruby"]
编写代码去除列表中重复的元素
先定义一个新的列表
循环取出每一个旧列表中的元素
判断这个元素是否已经存在于新列表中
存在则下一个
不存则添加添加
使用count判断每一个元素的个数
如果个数大于1 就删除 删到count为1为止
"""
old_list = ["python","java","C++","PHP","HTML","python","C++","Ruby"]
new_list = []
for i in old_list:
if i in new_list:
continue
else:
new_list.append(i)
print(new_list)
['python', 'java', 'C++', 'PHP', 'HTML', 'Ruby']4、
text = """
<p align="center"><a target="_blank" href="http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_01origin_01_201861619251A1.jpg"><img class="picact" border="0" alt="游民星空" src="http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_01small_02_201861619252E7.jpg"></a></p>
<p align="center"><a target="_blank" href="http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_02origin_03_20186161925574.jpg"><img class="picact" border="0" alt="游民星空" src="http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_02small_04_2018616192574A.jpg"></a></p>
<p align="center"><a target="_blank" href="http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_03origin_05_20186161925AF7.jpg"><img class="picact" border="0" alt="游民星空" src="http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_03small_06_20186161925F0C.jpg"></a></p>
<p align="center"><a target="_blank" href="http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_04origin_07_201861619251AE.jpg"><img class="picact" border="0" alt="游民星空" src="http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_04small_08_201861619254F2.jpg"></a></p>
<p align="center"><a target="_blank" href="http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_05origin_09_20186161925836.jpg"><img class="picact" border="0" alt="游民星空" src="http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_05small_10_20186161925B7A.jpg"></a></p>
<p>
"""
# 第一步 切割字符串 用双引号作为分割符
text_list = text.split('"')
for i in text_list:
if i.startswith("http"):
print(i)
-----------------------------------------------------------------------
http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_01origin_01_201861619251A1.jpg
http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_01small_02_201861619252E7.jpg
http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_02origin_03_20186161925574.jpg
http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_02small_04_2018616192574A.jpg
http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_03origin_05_20186161925AF7.jpg
http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_03small_06_20186161925F0C.jpg
http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_04origin_07_201861619251AE.jpg
http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_04small_08_201861619254F2.jpg
http://www.gamersky.com/showimage/id_gamersky.shtml?http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_05origin_09_20186161925836.jpg
http://img1.gamersky.com/image2018/06/20180616_djy_248_3/gamersky_05small_10_20186161925B7A.jpgtext = "language,is,perfect,hello,i am jack,python"
# 将其修改为"hello i am jack python is perfect language"
# 先将这个字符串用逗号切开 按照顺序重新拼接起来
text_list = text.split(",")
new_text = "%s %s %s %s %s %s" % (text_list[3],text_list[4],text_list[5],text_list[1],text_list[2],text_list[0])
print(new_text)
hello i am jack python is perfect language九、元祖类型
1、基本使用：tuple
# 1 用途：记录多个值，当多个值没有改的需求，此时用元组更合适
#
# 2 定义方式：在()内用逗号分隔开多个任意类型的值
t=(1,1.3,'xx',('a','b'),[1,2])
print(t,type(t))
t1=tuple('hello')
print(t1)# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
t=('egon',123,['a','b'])
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
t[2][0]='A'
print('='*50)
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
t[0]='EGON' # 元组中的元素为不可变类型
t[2]='xxxx' # 同上
t[2][0]='A' # 元祖中的元素为列表，可变
print(t)
-----------------------------------------------------
2420670902712
1570208592
2420673504648
==================================================
2420670902712
1570208592
2420673504648
('egon', 123, ['A', 'b'])2、切片(顾头不顾尾，步长)
t=(1,2,3,4,5)
print(t[0:3])
print(t)
-------------------
(1, 2, 3)
(1, 2, 3, 4, 5)3、长度
len
4、成员运算in和not in
5、循环
for item in ('a','b','c'):
print(item)# 需要掌握的操作
t=('a','b','c','a')
print(t.count('a'))
print(t.index('a',1,10))
-------------------------------
2
36 总结
该类型总结
# 1 存多个值
# 2 有序
#
# 3 不可变
# 不可变类型=》可hash类型
# 可变类型 =》不可以hash类型
十、字典类型
基本使用dict
# 1 用途：记录多个值，每一个值都对应的key用来描述value的作用
# 2 定义方式：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型
dic={0:'aaa',1:'bbb',2:'cccc'} #dic=dict({0:'aaa',1:'bbb',2:'cccc'})
print(dic,type(dic))
print(dic[0])
-------------------------------
{0: 'aaa', 1: 'bbb', 2: 'cccc'} <class 'dict'>
aaa# 用法一：
dic=dict(x=1,y=2,z=3)
print(dic)
{'x': 1, 'y': 2, 'z': 3}# 用法二：
userinfo=[
['name','egon'],
['age',18],
['sex','male']
]
d={}
for k,v in userinfo: #k,v=['name', 'egon']
# print(k,v)
d[k]=v
print(d)
d=dict(userinfo)
print(d)
--------------------------------------
{'name': 'egon', 'age': 18, 'sex': 'male'}
{'name': 'egon', 'age': 18, 'sex': 'male'}# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
dic={'name':'egon'}
print(dic['name'])
dic['name']='EGON'
print(dic)
dic['age']=18
print(dic)
--------------------------
egon
{'name': 'EGON'}
{'name': 'EGON', 'age': 18}2、长度len
dic={'name':'egon','age':18,'name':'EGON','name':'XXXX'}
print(dic)
print(len(dic))
---------------------------------
{'name': 'XXXX', 'age': 18}
2#3、成员运算in和not in:字典的成员运算判断的是key
dic={'name':'egon','age':18,}
print(18 in dic)
print('age' in dic)
-----------------------
False
True#4、删除
dic={'name':'egon','age':18,}# 通用
del dic['name']
print(dic)
---------------------
{'age': 18}
del dic['xxx'] ##key不存在则报错res=dic.pop('age') #删除key对应的value,并返回value
print(dic)
print(res)
# dic.pop('xxx') #key不存在则报错
res=dic.popitem()
print(dic)
print(res)
---------------------------------------
{'name': 'egon'}
18
{}
('name', 'egon')#5、键keys()，值values()，键值对items()
dic={'name':'egon','age':18,}
print(dic.keys())
l=[]
for k in dic.keys():
l.append(k)
print(l)
print(list(dic.keys()))
print(dic.values())
print(list(dic.values()))
print(dic.items())
print(list(dic.items()))
----------------------------------
dict_keys(['name', 'age'])
['name', 'age']
['name', 'age']
dict_values(['egon', 18])
['egon', 18]
dict_items([('name', 'egon'), ('age', 18)])
[('name', 'egon'), ('age', 18)]#6、循环
dic={'name':'egon','age':18,'sex':'male'}for k in dic.keys():
print(k,dic[k])
--------------------------
name egon
age 18
sex malefor k in dic:
print(k,dic[k])
-----------------------------
name egon
age 18
sex malefor v in dic.values():
print(v)
----------------------
egon
18
malefor k,v in dic.items():
print(k,v)
-------------------------
name egon
age 18
sex male7、dic.get()
dic={'name':'egon','age':18,'sex':'male'}
v=dic.get('name')
print(v)
egon# 需要掌握的操作
# dic.fromkeys()的用法:
l=['name','age','sex']
dic={}
for k in l:
dic[k]=None
print(dic)
dic=dic.fromkeys(l,None)
print(dic)
---------------------------------
{'name': None, 'age': None, 'sex': None}
{'name': None, 'age': None, 'sex': None}old_dic={'name':'egon','age':18,'sex':'male'}
new_dic={'name':'EGON','x':1,'y':2}
old_dic.update(new_dic)
print(old_dic)
-------------------------------
{'name': 'EGON', 'age': 18, 'sex': 'male', 'x': 1, 'y': 2}# setdefault:有则不动/返回原值,无则添加/返回新值
dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON') # 字典中已经存在key则不修改,返回已经存在的key对应的value
print(dic)
print(res)
--------------------------
{'name': 'egon', 'age': 18}
egon# 字典不存在key则添加"sex":"male",返回新的value
dic={'name':'egon','age':18}
res=dic.setdefault('sex','male')
print(dic)
print(res)
----------------------
{'name': 'egon', 'age': 18, 'sex': 'male'}
male该类型总结：
# 1 存多个值
# 2 无序
#
# 3 可变
dic={'x':1}
print(id(dic))
dic['x']=2
print(id(dic))
-------------------------
2813251775656
2813251775656练习1：
nums=[11,22,33,44,55,66,77,88,99,90]
dic={
'k1':[],
'k2':[]
}
for num in nums:
if num > 66:
dic['k1'].append(num)
else:
dic['k2'].append(num)
print(dic)
-------------------------------------
{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}练习2：
s='hello alex alex say hello sb sb'
words=s.split()
dic={}
print(words)
for word in words:
if word in dic:
dic[word]+=1
else:
dic[word]=1
print(dic)
-----------------------------
['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb']
{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}s='hello alex alex say hello sb sb'
words=s.split()
dic={}
for word in words: # word="hello"
dic.setdefault(word,words.count(word)) #{'hello':2,"alex":2,"say":1,}
print(dic)
-------------------------------
{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}练习3
pythons=['李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy']
linuxs=['lxx','egon','张金蛋','张锡蛋','alex','陈独秀']
l=[]
for stu in pythons:
if stu in linuxs:
l.append(stu)
print(l)
['张金蛋', '张锡蛋', 'alex']十一、set的基本使用
# 1 用途: 关系运算,去重
#
# 2 定义方式: 在{}内用逗号分开个的多个值
# 集合的三大特性:
# 2.1 每一个值都必须是不可变类型
# 2.2 元素不能重复
# 2.3 集合内元素无序
s={1,3.1,'aa',(1,23),} # s=set({1,3.1,'aa',(1,23),})
print(s,type(s))
s={1,1,1,1,1,1,1,1,1,2,3}
print(s)
s={'a','b','c'}
# s[0] # 无序
s1=set('hello')
print(s1)
-------------------------------
{1, 'aa', 3.1, (1, 23)} <class 'set'>
{1, 2, 3}
{'h', 'o', 'e', 'l'}# 3 常用操作+内置的方法
pythons={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy'}
linuxs={'lxx','egon','张金蛋','张锡蛋','alex','陈独秀'}
# 取及报名python课程又报名linux课程的学员:交集
print(pythons & linuxs)
print(pythons.intersection(linuxs))
---------------------------------------
{'张金蛋', 'alex', '张锡蛋'}
{'张金蛋', 'alex', '张锡蛋'}
# 取所有报名老男孩课程的学员:并集
print(pythons | linuxs)
print(pythons.union(linuxs))
----------------------------------
{'李二丫', 'alex', '张金蛋', 'lxx', 'egon', '陈独秀', '赵铜蛋', '李银弹', '张锡蛋', 'oldboy'}
{'李二丫', 'alex', '张金蛋', 'lxx', 'egon', '陈独秀', '赵铜蛋', '李银弹', '张锡蛋', 'oldboy'}
# 取只报名python课程的学员: 差集
print(pythons - linuxs)
print(pythons.difference(linuxs))
----------------------------------------
{'赵铜蛋', '李银弹', '李二丫', 'oldboy'}
{'赵铜蛋', '李银弹', '李二丫', 'oldboy'}
# 取只报名linux课程的学员: 差集
print(linuxs - pythons)
print(linuxs.difference(pythons))
---------------------------------------
{'lxx', '陈独秀', 'egon'}
{'lxx', '陈独秀', 'egon'}
# 取没有同时报名两门课程的学员:对称差集
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))
--------------------------------------
{'lxx', '赵铜蛋', '李二丫', '陈独秀', 'egon', '李银弹', 'oldboy'}
{'lxx', '赵铜蛋', '李二丫', '陈独秀', 'egon', '李银弹', 'oldboy'}
# 是否相等
s1={1,2,3}
s2={3,1,2}
print(s1 == s2)
True
# 父集:一个集合是包含另外一个集合
s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))
True
True
s1={1,2,3}
s2={1,2,4}
print(s1 >= s2)
False
# 子集
s1={1,2,3}
s2={1,2}
print(s2 <= s1)
print(s2.issubset(s1))
True
True
# 需要掌握操作
s1={1,2,3}
s1.update({3,4,5})
print(s1)
{1, 2, 3, 4, 5}
#随机删（因为集合是无序的）
s1={1,2,3}
res=s1.pop()
print(res)
1
#单纯的删除,返回值为None，制定元素删除
s1={1,2,3}
res=s1.remove(3)
print(s1)
{1, 2}
# 添加元素 4
s1={1,2,3}
s1.add(4) # 添加元素 4
print(s1)
{1, 2, 3, 4}
s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)
{3}
#单纯的删除,返回值为None
s1={1,2,3}
res=s1.discard(3)
print(s1)
print(res)
s1.remove(444444) #删除的元素不存在则报错
s1.discard(444444) #删除的元素不存在不会报错
#如果两个集合没有交集则返回True ,不会报错
s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2))
False
s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True
True该类型总结:
# 1 存多个值
#
# 2 无序
#
# 3 set可变
s={1,2,3}
print(id(s))
s.add(4)
print(id(s))
1935460119720
1935460119720# 集合去重
# 局限性
#1、无法保证原数据类型的顺序
#2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
names=['alex','egon','alex','alex','egon','lxx']
s=set(names)
print(s)
l=list(s)
print(l)
{'alex', 'egon', 'lxx'}
['alex', 'egon', 'lxx']
-------------------------------------------
stus_info=[
{'name':'egon','age':18},
{'name':'alex','age':73},
{'name':'oldboy','age':84},
{'name': 'egon', 'age': 18},
{'name': 'egon', 'age': 18},
{'name': 'egon', 'age': 18},
{'name': 'oldboy', 'age': 84},
]
l=[]
for info in stus_info:
if info not in l:
l.append(info)
print(l)
[{'name': 'egon', 'age': 18}, {'name': 'alex', 'age': 73}, {'name': 'oldboy', 'age': 84}]
-----------------------------------------------------------------------------------------------
#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>=
#9、子集：<,<=十二、字符编码
一 储备知识点1
运行程序的三大核心硬件
cpu
内存
硬盘
运行一个程序：
代码由硬盘读入内存，cpu从内存中读取指令执行
强调：程序运行过程中产生的数据一定是最先存放于内存中的
二 储备知识点2
运行python程序的三个阶段：python test.py
1、先启动python解释器
2、将test.py的内容当作普通字符读入内存
3、python解释器解释执行读入内存的代码，识别python的语法
python解释器运行程序的前两个阶段跟文本编辑器一模一样
只有第三个阶段不同
三 字符编码
人操作计算机使用人类认识的字符，而计算机存放都是二进制数字
所以人在往计算机里输入内容的时候，必然发生：
人类的字符------（字符编码表）--------》数字
ASCII: 用(8位bit二进制数)1Bytes对应一个英文字符
8bit= 1Bytes
1024Bytes=1KB
1024KB=1MB
1024MB=1GB
1024GB=1TB
1024TB=1PB
GBK：用2Bytes对应一个中文字符，1Bytes对应一个英文字符
unicode：用2Bytes对应一个字符
必须满足两大特点：
1、能够兼容万国字符
2、与老字符编码都有一种数字与数字的对应关系
a 1111 0111
a 0000 0000 1111 0111
utf-8:Unicode Transformation Format
一个中文字符：3bytes
一个英文字符：1bytes
强调：
unicode格式的数字--------encode编码---------》utf-8格式的数字
unicode格式的数字《--------decode解码《---------utf-8格式的数字
# 计算机到用户识别 从硬盘读取---->> unicode格式数字 ---》encode 编码-----》 utf-8 格式数字---->>转成用户识别
# 用户到计算机识别 用户输入---》utf-8---》 decode解码---->> unicode格式数字---->转成二进制存入硬盘作业：
默写:
1.元组 字典 集合 列表 各自的特点
2.字典添加 删除 修改 循环
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
d={"a":1,"b":2,"c":3}
根据关键字删除：d.pop("a")
d.update({"r":7}) 没有则添加，有则修改
打印key
for i in d:
print(i)
打印value
for i in d:
print(d[i])
打印key，value
for k,v in d.items():
print(k,v)
必做:
1.餐厅提供了五种不同的菜,使用元组来存储他们,并循环打印出所有菜名,要求用户输入新加的菜名,加入到菜单中,并重新输出
2.使用列表存储1-10所有的平方数
3.使用三种不同的语法 创建内容包含name和age的字典
4.在使用字典存储你和你左右同学的信息然后将它们存储在一个列表中最后循环输出所有信息
5.请写出代码验证 交集 合计 对称差集 差集 子集 父集的效果
6.举例子说明元组 列表 集合 的使用场景
7.对于字典 有多重方式可以删除一个键值对
dic.pop("key")
dic.remove("key")
两种方法有什么不同
尝试:
编写程序实现以下功能
要求用户输入音乐数据 包括 类型,名字,作者,时长,发布时间
每种类型可以有多个音曲目信息(循环录入多个曲目)
输入指定命令可以退出输入
输入完成后
可以按照类型查看音乐
可以按照名称查看音乐
拓展,按照名称查看时 可以模糊查找 例如 输入 气球 可以查看到 告白气球
注:先完成录入部分 在完成查看信息部分
数据样例:
{
"pop":[
{
"title":"告白气球",
"auth":"周杰伦",
"time":"3:54"
"date":"2017-09-20"
}
]
"rock":[
{
"title":"一无所有",
"auth":"周建",
"time":"4:50",
"date":"1987-10-02"
}
]
}转载于:https://blog.51cto.com/silencezone/2348813
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
