vue主题测试

print("hello world")

Python笔记

算你赢

输入函数input()

#输入函数：input
present=input('大圣想要什么礼物呢？')
print(present,type(present))

input函数的高级使用

#从键盘录入两个整数，计算两个整数的和
a=int(input('请输入一个加数：'))
#a=int(a)强制类型转换，a,b原本是字符串；
b=int(input('请输入另一个加数：'))
print(type(a),type(b))
print(a+b)

#输出
'''大圣想要什么礼物呢？定海神针
定海神针 <class 'str'>
请输入一个加数：10
请输入另一个加数：20
<class 'int'> <class 'int'>
30'''

---

Python的运算符

算术运算符：

• 加(+)、减(-)、乘(*)、除(/)、整除(//)与C不同:（整除：一正一负向下取整数）
• 取余运算符(%)
• 幂运算符(**)

#算术运算符
print(1+1)
print(1-1)
print(2*4)
print(1/2)#除法运算：0.5
print(11//2)#整除运算：5
print(11%2)
print(2**4)#幂运算：16

print(9//4)
print(-9//-4)
print(-9//4)#一正一负向下取整：-3
print(9//-4)#一正一负向下取整：-3

print(9%-4) # -3
print(-9%4) # 3

赋值运算符：

• 链式赋值
• 参数赋值（地址相同）
• 系列解包赋值（左右个数必须相同）

#赋值运算符   运算顺序从右向左
i=3+4
print(i)
a=b=c=20   #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))  #均为 20 2316881232720（地址相同）
print("--------支持参数赋值-------------")
d=30
d+=20   #d=d+20;
print(d)

#支持系列解包赋值
print("--------支持系列解包赋值-------------")
a,b,c=20,30,40  #左右个数必须相同
print(a,b,c)
print("--------交换两个变量的值-------------")
a,b=10,20
print("交换之前：",a,b)
a,b=b,a
print("交换之后：",a,b)

比较运算符：

• 比较运算符的结果为bool类型

#比较运算符(结果为bool类型）
a,b=10,20
print("a>b吗？",a>b)  #False
print("a<b吗？",a<b)  #True
print("a<=b吗？",a<=b)    #True
print("a>=b吗？",a>=b)    #False
print("a==b吗？",a==b)    #False
print("a!=b吗？",a!=b)    #True
'''一个变量由三部分组成：标识，类型，值
    ==  比较的是值还是标识呢？比较的是值！！！
    比较对象的标识使用的是 is
'''
a=10
b=10
print(a == b)   #True 说明a与b的value相等
print(a is b)   #True 说明a与b的id标识相同
lst1={11,22,33,44}
lst2={11,22,33,44}
print(lst1 == lst2)   #value ->True
print(lst1 is lst2)   #id ->False   id不相同
print(id(lst1),id(lst2))    #2068108092000 2068111444000    id不相同
print(a is not b)#False
print(lst1 is not lst2)#True

布尔运算符：

#布尔运算符
print("-------------布尔运算符------------")
a,b=1,2
print("-----------and 并且--------------")
print(a==1 and b==2)    #True and True->True
print(a==1 and b<2)     #True and False->False
print(a!=1 and b==2)    #False and True->False
print(a!=1 and b!=2)    #False and False->False

print("------------or 或者--------------")
print(a==1 or b==2)     #True or True->True
print(a==1 or b<2)      #True or False->True
print(a!=1 or b==2)     #Flase or True->True
print(a!=1 or b!=2)     #Flase or Flase->False

print("----------------not 对bool类型的操作数取反--------------")
f=True
f2=False
print(not f)
print(not f2)

print("---------------in 与 not in--------------------------")
s='helloworld'
print('w' in s)     #在->True
print('k' in s)     #不在->Flase
print('w' not in s)     #谁说不在？->Flase
print('k' not in s)     #属实在呢！->True

位运算符：

#位运算
print(4&8)      #按位与运算，同为1则为1，不同为1则为0；
print(4|8)      #按位或运算，有1则1；

print(4<<1)     #向左移动1位：8
print(4<<2)     #向左移动2位：16

print(4>>1)     #向右移动1位：2
print(4>>2)     #向右移动2位：1

• 按位与或运算

• 左移左移一位，相当于乘2

  

• 右移右移一位，相当于除以2

  

Python运算符的优先级

• `算术运算->位运算->比较运算->布尔运算->赋值运算

---

知识点总结

---

---

---

往哪走呢？

程序的组织结构<顺序结构、选择结构、循环结构>

顺序结构：

• 程序从上到下顺序地执行代码，中间没有任何的判断和跳转，直到程序结束

#顺序结构
'''把大象装进冰箱一共分几步'''
print("------------程序开始--------------")
print("1.把冰箱门打开")
print("2.把大象放进冰箱")
print("3.把冰箱门关上")
print("------------程序结束--------------")

对象的布尔值：

• Python一切皆对象，所有对象都有一个布尔值

  • 获取对象的布尔值
    • 使用内置函数bool()

• 以下对象的布尔值为False**(空)**

  • False
  • 数值0
  • None
  • 空字符串
  • 空列表
  • 空元组
  • 空字典
  • 空集合

#测试对象的布尔值
print("------------以下对象的布尔值为False----------------")
print(bool(False))  #False
print(bool(0))  #False
print(bool(0.0))    #False
print(bool(None))   #False
print(bool('')) #False 字符串长度为零
print(bool("")) #False 字符串长度为零
print(bool([])) #空列表 False
print(bool(list())) #空列表 False
print(bool(()))    #空元组 False
print(bool(tuple()))    #空元组 False
print(bool({}))     #空字典 False
print(bool(dict()))     #空字典 False
print(bool(set()))      #空集合 False

print("------------其它对象的布尔值全为True---------------")
print(bool(18))
print(bool('helloworld'))

选择结构：

• 程序根据判断条件的布尔值选择性地执行部分代码，明确的让计算机知道在什么条件下，该去做什么

单分支结构

if 条件表达式：

​ 条件执行体

print("-----------------单分支结构--------------------------")
money=1000 #余额；
s=int(input("请输入取款金额："))       #取款金额
#判断余额是否充足
if money>=s:
    money-=s
    print("取款成功，余额为：",money)

双分支结构

if 条件表达式：

​ 条件执行体

else:

​ 条件执行体

print("-----------------双分支结构--------------------------")
#从键盘录入一个整数，判断它是奇数还是偶数
num=int(input("请输入一个整数："))
if num%2==0:
    print(num,"为偶数")
else:
    print(num,"为奇数")

多分支结构

if 条件表达式：

​ 条件执行体

elif 条件表达式2：

​ 条件执行体2

elif 条件表达式N：

​ 条件执行体N

[else:]

​ 条件执行体N+1：

print("-----------------多分支结构--------------------------")
'''多分支结构，多选一执行
    从键盘录入一个整数：成绩
    90——100：A
    80——89：B
    70——79：C
    60——69：D
    0——59：E
    小于0或者大于100属于非法数据（不是成绩的有效范围）
    '''
score=int(input("请输入一个整数："))
if score>=90 and score<=100:  #可以90<=score<=100，下列依次都可以，Python中可以这样判断。
    print("A级")
elif score>=80 and score<=89:   
    print("B级")
elif score>=70 and score<=79:
    print("C级")
elif score>=60 and score<=69:
    print("D级")
elif score>=0 and score<=59:
    print("E级")
else:
    print("error:成绩有误！")

嵌套if

if 条件表达式1：

​ if 内层条件表达式：

​ 内层条件执行体1

​ else：

​ 内层条件执行体2

else：

​ 条件执行体

print("-----------------嵌套if-----------------------")
'''会员   >=200   打8折
        >=100  打9折
        不打折
   非会员     >=200   打9.5折
             不打折'''
answer=input("您是会员吗？y/n")
money=float(input("请输入您的购物金额："))
if answer=='y':     #会员
   if money>=200:
       print("打8折，付款金额为：",money*0.8)
   elif money>=100:
       print("打9折，付款金额为：",money*0.9)
   else:
       print("不打折，付款金额为：",money)
else:       #非会员
   if money>=200:
       print("打9.5折，付款金额为：",money*0.95)
   else:
       print("不打折，付款金额为：",money)

条件表达式

x if 判断条件 else y

• 运算规则：

  ​ 如果判断条件的布尔值为True,条件表达式的返回值为x,否则条件表达式的返回值为False;

Python:

#使用条件表达式进行比较
num_a=int(input("请输入一个整数："))
num_b=int(input("请输入另一个整数："))
print(num_a,"大于等于",num_b) if num_a>=num_b else print(num_a,"小于",num_b)
print(str(num_a)+"大于等于"+str(num_b) if num_a>=num_b else str(num_a)+"小于"+str(num_b))     #妙法！

C语言:

//条件表达式
int a = 2, b = 1;
	a > b ? printf("%d大于等于%d", a,b) : printf("%d小于%d",a,b);

自我感觉C语言更简单耶✌！

Pass语句

• 语句什么都不做，只是一个占位符，用在语法上需要语句的地方

• 什么时候使用：

  • 先搭建语法结构，还没想好代码怎么写的时候

• 哪些语句一起使用：

  • if语句的条件执行体；
  • for-in语句的循环体；
  • 定义函数时的函数体。

#Pass语句：什么都不做，只是一个占位符，用在需要写语句的地方
answer=input("您是会员吗？y/n")
if answer==y:
    pass
else:
    pass

知识点总结

转圈圈

range()函数的使用

#range()的三种创建方式
'''第一种创建方式：range(stop)'''
r=range(10)     #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],默认从0开始，默认相差1称为步长；
print(r)    #range(0,10)
print(list(r))  #用于查看range对象中的整数序列  ——>list是列表的意思
'''第二种创建方式：range(start,stop)'''
r=range(1,10)       #指定了初始值，从1开始，到10结束（不包括10），默认步长为1；
print(list(r))      #[1, 2, 3, 4, 5, 6, 7, 8, 9]
'''第三种创建方式：range(start,stop,step)'''
r=range(1,10,2)
print(list(r))      #[1, 3, 5, 7, 9]
'''判断指定的整数 在序列中是否存在 in,not in'''
print(10 in r)     #False,10不在当前的r这个整数序列中
print(9 in r)      #True，9在当前的r这个序列中

print(10 not in r)   #True
print(9 not in r)    #False

while循环

同C语言一样

'''计算1到100之间的偶数和'''
sum=0 #用于存储偶数和
a=1 #初始化变量
while a<=100:   #条件判断
    '''判断是否为偶数'''
    if not bool(a%2):
        sum+=a
    a+=1
print("1到100之间的偶数和:",sum)  #2550

for-in循环

break、continue与else语句

• break语句：（用于结束循环结构，通常与分支结构if一起使用）

  '''从键盘录入密码，最多录入三次，如果正确就结束循环'''
  for item in range(3):
      pwd=input("请输入密码：")
      if pwd=="8888":
          print("密码正确")
          break
      else:
          print("密码不正确")
  

  ---

  #annther way:
  a=0
  while a<3:
      pwd=input("请输入密码：")
      if pwd=="8888":
          print("密码正确")
          break
      else:
          print("密码不正确")
      a+=1
  

• 流程控制语句continue（用于结束当前循环，进入到下一次循环，通常与分支结构if一起使用）

  '''要求输出1到50之间5的倍数：5，10，15，...'''
  for i in range(1,51):   #利用continue语句
      if i%5:
          continue
      print(i)
  

  ---

  #another way:
  for i in range(1,51):
      if i%5==0:
          print(i)
  

• else语句：

  

'''从键盘录入密码，最多录入三次，如果正确就结束循环'''
for item in range(3):
    pwd=input("请输入密码：")
    if pwd=="8888":
        print("密码正确")
        break
    else:
        print("密码不正确")
else:
    print("对不起，你三次密码均输入错误！")
#annther way:
a=0
while a<3:
    pwd=input("请输入密码：")
    if pwd=="8888":
        print("密码正确")
        break
    else:
        print("密码不正确")
    a+=1
else:
    print("对不起，你三次密码均输入错误！")

未被break跳出循环->else

循环嵌套

• 嵌套循环

'''输出一个三行四列的矩阵'''
for i in range(1,4):
    for j in range(1,5):
        print("*",end="\t")     #不换行输出
    print()     #打行

---

print("-------------------打印9*9乘法表---------------------------")
for i in range(1,10):
    for j in range(1,i+1):
        print(i,"*",j,"=",i*j,end="\t")
    print()

• 二重循环中的break与continue（只用于控制本层的循环）

'''流程控制语句break与continue在二重循环中的使用'''
for i in range(5):  #代表外层循环进行5次
  for j in range(1,11):
    if j%2==0:
        break	#continue
    print(j)   #1  1   1   1   1

知识点总结

与C语言的不同：for-in循环遍历可迭代对象，借助range()函数，else语句的使用

一字排开

列表相当于数组

列表的存储：

·列表的创建与删除

• 列表的创建

  + 使用中括号

  + 使用内置函数list()

  #列表的创建
  '''创建列表的第一种方式：使用中括号'''
  lst=['Hello','World',98]
  '''创建列表的第二种方式：使用内置函数list()'''
  lst2=list(['Hello','World',98])
  

·列表的查询操作

• 列表的特点

  

lst=['Hello','World',98,'Hello']
print(lst)      #['Hello', 'World', 98, 'Hello']
print(lst[0],lst[-4])   #Hello Hello

• 获取列表中指定元素的索引

  

#列表的查询操作
#获取指定元素的索引
lst=['Hello','World',98,'Hello']
print(lst.index('Hello'))   #0  如果列表中存在相同元素只返回列表中相同元素的第一个元素的索引
'''print(lst.index('Python'))  #ValueError: 'Python' is not in list
print(lst.index('Hello',1,3))   #ValueError: 'Hello' is not in list  从World开始到Hello（不包括Hello），没有Hello。'''
print(lst.index('Hello',1,4))   #3

• 获取列表中的单个元素

  

#获取列表中的单个元素
lst=['hello','world',1314,'hello','world',521]
#获取索引为2的元素：
print(lst[2])
#获取索引为-1的元素：
print(lst[-1])
#print(lst[10])  #IndexError: list index out of range

• 获取列表中的多个元素

  • 语法格式

    

#获取列表中的多个元素
lst=[10,20,30,40,50,60,70,80,90]
#start=1,stop=6,step=1:
print(lst[1:6:1])   #[20, 30, 40, 50, 60]
lst2=lst[1:6:1]
print('原列表id：',id(lst))     #原列表id： 1687061297280
print('切片列表id:',id(lst2))       #切片列表id: 1687061326656
'''切片是将原列表片段的拷贝'''
print(lst[1:6])     #默认step=1
print(lst[1:6:2])   #[20, 40, 60]
#stop=6,step=2,start采用默认：
print(lst[:6:2])    #[10, 30, 50]   start默认为0；
#start=1,step=2,stop采用默认：
print(lst[1::2])    #[20, 40, 60, 80]   stop默认为最后一位.
print('---------------------------step为负数------------------------------------')
print('原列表：',lst)       #原列表： [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(lst[::-1])        #[90, 80, 70, 60, 50, 40, 30, 20, 10]
#start=8,stop采用默认，step=-1：
print(lst[8::-1])           #[90, 80, 70, 60, 50, 40, 30, 20, 10]
#start=8，stop=0,step=-2:
print(lst[8:0:-2])      #[90, 70, 50, 30]   stop=0不包括在内！！！

• 判断指定元素在列表中是否存在（使用in / not in)**

  判断结果为True、False.

• 列表元素的遍历

  #列表元素的遍历
  lst=[1314,521,'xiling','duoqing','ruwo']
  for item in lst:
      print(item)
  

·列表元素的增、删、改操作

• 列表元素的增加：
  

#列表元素的添加：
print('---------------------lst.append--------------------------------')
lst=['xiling','did','you','love','me','?']
print('添加前的lst',lst,id(lst))
lst.append('maybe not ...')     #在lst末尾添加1个元素...
print('添加后的lst',lst,id(lst))
'''2070582687872:id并未发生改变！！！'''
lst=['xiling','did','you','love','me','?']
lst2=['maybe','never','.']
lst.append(lst2)
print(lst)   #['xiling', 'did', 'you', 'love', 'me', '?', ['maybe', 'never', '.']]把lst2作为一个元素添加到了lst末尾。

---

print('---------------------lst.extend--------------------------------')
lst=['xiling','did','you','love','me','?']
lst2=['maybe','never','.']
lst.extend(lst2)
print(lst)  #['xiling', 'did', 'you', 'love', 'me', '?', 'maybe', 'never', '.']可以添加最少一个元素到lst末尾！！！

---

print('---------------------lst.insert--------------------------------')
'''在任意位置插入一个元素'''
lst=['xiling', 'did', 'you', 'love', 'me', '?', 'maybe', '.']
lst.insert(7,'never')
print(lst)      #['xiling', 'did', 'you', 'love', 'me', '?', 'maybe', 'never', '.']

---

'''在任意位置添加N多个元素——切片'''
lst=['xiling', 'did', 'you', 'love', 'me', '?', 'maybe', 'never', '.']
lst3=['to','be','myself','!']
lst[6:]=lst3
print(lst)      #['xiling', 'did', 'you', 'love', 'me', '?', 'to', 'be', 'myself', '!']

• 列表元素的删除：

  

'''元素的移除'''
#remove()移除指定元素
lst=[10,20,30,40,50,60,30]
lst.remove(30)  #从列表中移除一个元素，如果有重复的元素则移除第一个
print(lst)  #[10, 20, 40, 50, 60, 30]
'''lst.remove(100)
print(lst)  #ValueError: list.remove(x): x not in list'''

---

#pop()根据索引移除元素
lst=[10,20,40,50,60,30]
print(id(lst))
lst.pop(1)
print(lst)  #[10, 40, 50, 60, 30]
'''lst.pop(5)
print(lst)  #IndexError: pop index out of range 如果指定的索引位置不存在，将抛出异常'''
lst.pop()
print(lst)      #[10, 40, 50, 60]  pop()未指定索引，默认为移除最后一位。
print(id(lst))  #id:1921088154432   id未发生改变

---

print('---------------------切片操作-删除最少一个元素，将产生一个新的列表对象------------------------')
lst=[10, 40, 50, 60]
new_list=lst[1:3]
print('原列表：',lst)       #原列表： [10, 40, 50, 60]
print('切片后的列表：',new_list)   #切片后的列表： [40, 50]
'''不产生新的列表对象，而是删除原列表中的内容'''
lst[1:3]=[]
print(lst)  #[10, 60]

---

'''清除列表中的所有元素'''
lst=[10,60]
lst.clear()
print(lst)  #[]

---

'''del语句将列表对象删除'''
lst=[]
del lst
#print(lst)  #NameError: name 'lst' is not defined.

• 修改列表中的元素：

  • 为指定的索引元素赋予一个新值==（一次修改一个元素）==

  • 为指定的切片赋予一个新值==（一次修改多个元素）==

    '''修改列表中的元素'''
    lst=[10,20,30,40]
    #一次修改一个值：
    lst[2]=100
    print(lst)      #[10, 20, 100, 40]
    #一次修改多个值：
    lst[1:3]=[300,400,500,600]
    print(lst)      #[10, 300, 400, 500, 600, 40]
    

·列表元素的排序

• 常见的两种方式：

  • 调用sort()方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True,进行降序排序

    '''列表元素的排序'''
    lst=[1,3,1,4,5,2,1]
    print('排序前的列表：',lst,id(lst))    #排序前的列表： [1, 3, 1, 4, 5, 2, 1]  2263579612288
    #开始排序，调用列表对象中的sort方法，升序排序
    lst.sort()
    print('排序后的列表：',lst,id(lst))    #排序后的列表： [1, 1, 1, 2, 3, 4, 5]  2263579612288
    ''' id并未发生改变，说明在原列表的基础上进行排序。'''
    #通过指定关键字参数，将列表中的元素进行降序排序
    lst.sort(reverse=True)      #reverse=True为降序排序，reverse=False为升序排序
    print(lst)  #[5, 4, 3, 2, 1, 1, 1]
    lst.sort(reverse=False)
    print(lst)  #[1, 1, 1, 2, 3, 4, 5]
    

  • 调用内置函数sorted(),可以指定reverse=True，进行降序排序，原列表不发生改变

    print('-------------------------调用内置函数sorted(),将产生一个新的列表对象--------------------------')
    lst=[1,3,1,4,5,2,1]
    print('原列表：',lst,id(lst))   #原列表： [1, 3, 1, 4, 5, 2, 1] 2185446717120
    #排序
    new_list=sorted(lst)
    print('排序后的列表：',new_list,id(new_list))  #排序后的列表： [1, 1, 1, 2, 3, 4, 5] 3154032579712
    '''id发生改变，说明产生了一个新的列表对象'''
    #指定关键字参数，将列表中的元素进行降序排序
    new_list=sorted(lst,reverse=True)
    print(lst,id(lst))  #[1, 3, 1, 4, 5, 2, 1]  2185446717120:id与原列表一致.
    

·列表推导式==(简称生成列表的公式)==

• 语法格式：

  

#列表生成式：
lst=[i*i for i in range(1,10)]
print(lst)  #[1, 4, 9, 16, 25, 36, 49, 64, 81]
#打印2，4，6，8，10：
lst2=[i*2 for i in range(1,6)]
print(lst2) #[2, 4, 6, 8, 10]

• 注意事项：

  “表示列表元素的表达式”中通常包含自定义变量

知识点总结

夫妻站

·什么是字典

无序

str不可变序列

·字典的原理

·字典的创建与删除

• 最长使用的方式：花括号

  

• 使用内置函数dict()

  

'''字典的创建方式'''
#使用{}创建字典：
scores={'张三':34,'李四':76}
print(scores)   #{'张三': 34, '李四': 76}
print(type(scores))     #<class 'dict'>

#使用内置函数dict()创建字典：
student=dict(name='jack',age=30)
print(student)  #{'name': 'jack', 'age': 30}

#空字典
d={}
print(d) #{}

·字典的查询操作

• 字典中元素的获取：

  

'''获取字典中的元素'''
scores={'张三':34,'李四':76}
'''第一种方式：[]'''
print(scores['张三'])    #34
#print(scores['王五'])     #KeyError: '王五'

'''第二种方式：使用get()方法'''
print(scores.get('张三'))     #34
print(scores.get('王五 '))    #None
print(scores.get('jerry',99))   #99:是在查找'jerry'所对应的value值不存在时，提供的一个默认值。

• []取值与get()取值的区别：

  • []如果字典中不存在指定的key,抛出KeyError异常；
  • get()方法取值，如果字典中不存在指定的key,并不会抛出KeyError，而是返回None,可以通过参数设置默认的value,以便指定的key不存在时返回.

• key的判断

  

·字典元素的增、删、改操作

• 字典元素的删除：

  

• 字典元素的增加(修改)：

  

'''字典元素的删除'''
del scores['张三']    #删除指定的key-value对
print(scores)   #{'李四': 76}
scores.clear()  #清空字典的元素
print(scores)   #{}

'''字典元素的增加'''
scores['王五']=9
print(scores)   #{'王五': 9}

'''字典元素的修改'''
scores['王五']=11
print(scores)   #{'王五': 11}

• 获取字典视图的三种方式：

  

scores={'张三':99,'李四':76,'王五':23}
#获取所有的key:
keys=scores.keys()
print(keys)     #dict_keys(['张三', '李四', '王五'])
print(type(keys))   #<class 'dict_keys'>
print(list(keys))   #['张三', '李四', '王五']     将所有key组成的视图转换成列表
#获取所有的value:
values=scores.values()
print(values)   #dict_values([99, 76, 23])
print(type(values)) #<class 'dict_values'>
print(list(values)) #[99, 76, 23]
#获取所有的key-value对：
items=scores.items()
print(items)    #dict_items([('张三', 99), ('李四', 76), ('王五', 23)])
print(type(items))  #<class 'dict_items'>
print(list(items))  #元组()转换过后的列表是由元组组成的   [('张三', 99), ('李四', 76), ('王五', 23)]

• 字典元素的遍历：

  

'''字典元素的遍历'''
scores={'张三':99,'李四':76,'王五':23}
for item in scores:
    print(item,scores[item],scores.get(item))
'''张三 99 99
    李四 76 76
    王五 23 23'''

• 字典的特点
  • 字典中的所有元素都是一个key-value对，key不允许重复，value允许重复；
  • 字典中的元素是无序的；
  • 字典中的key必须是不可变对象；
  • 字典也可以根据需要动态地伸缩；
  • 字典会浪费较大的内存，是一种空间换时间的数据结构.

d={'name':'张三','name':'李四'} #key不允许重复，否则会出现值覆盖。
print(d)    #{'name': '李四'}

d={'name':'张三','nickname':'张三'} #value可以重复。
print(d)    #{'name': '张三', 'nickname': '张三'}

lst=[1,1,2]
lst.insert(1,100)
print(lst)  #[1, 100, 1, 2]
'''d={lst:100}
print(d)    #TypeError: unhashable type: 'list' 字典中的key必须是不可变对象，而list可改变。'''

·字典推导式

• 内置函数zip()
  • 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。

• 字典生成式

  

#字典生成式：
items=['Fruits','Books','Others']
prices=[96,78,85,100,100]

d={item.upper():price for item,price in zip(items,prices)}
print(d)    #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

知识点总结