python基础04

Python基础知识04

目录

一、字典

二、集合

三、控制语句

---

一、字典

    “键值对”的无序可变序列。每个元素包含“键对象”和“值对象”。“键”是任意不可变数据，如整数、浮点数、字符串、元祖。列表、字典、集合这些可变对象不能作为“键”。并且键不能重复，值可是任意数据，可重复。

（一）字典的创建方式

1.通过{}；dict()创建

2.zip()创建

3.通过dict.fromkeys()创建值为空的字典

1.  
   #{}和dict()创建
2.  
   >>> a = {'name':'lcc','age':'18','job':'techer'}
3.  
   >>> b = dict(name='lcc',age=18,job='techer')
4.  
   >>> c = {}
5.  
   >>> d = dict()
6.  
    
7.  
   #zip()创建
8.  
   >>> k = ['name','age','job']
9.  
   >>> v = ['lcc','18','techer']
10.  
    >>> d = dict(zip(k,v))
11.  
    >>> d
12.  
    {'name': 'lcc', 'age': '18', 'job': 'techer'}
13.  
     
14.  
    #dict.fromkeys()创建值为空的字典
15.  
    >>> a = dict.fromkeys(['name','age','job'])
16.  
    >>> a
17.  
    {'name': None, 'age': None, 'job': None}

（二）字典元素的访问

1.通过[键]获得值，键不存在抛异常

2.get()：不存在返回none或自定义返回内容。推荐使用。

1.  
   >>> a.get('name')
2.  
   'lcc'
3.  
   >>> a.get('color','不存在')
4.  
   '不存在'

3.items()列出所有键值对

1.  
   >>> a.items()
2.  
   dict_items([('name', 'lcc'), ('age', '18'), ('job', 'techer')])

4.keys()、values()列出所有的键、值

5.len()：键值对的个数

6.“in”检测键是否在字典中

（三）字典元素的添加、修改、删除

1.新增键值对，若已有键则覆盖，若无则新增键值对。

1.  
   >>> a = {'name':'lcc','age':18,'job':'techer'}
2.  
   >>> a['address']='涅阳路'
3.  
   >>> a
4.  
   {'name': 'lcc', 'age': 18, 'job': 'techer', 'address': '涅阳路'}

2.update()：将新字典键值添加到新字典上，如有key重复，则覆盖。

1.  
   >>> a = {'name':'lcc','age':18,'job':'techer'}
2.  
   >>> b = {'money':'1000','address':'涅阳路'}
3.  
   >>> a.update(b)
4.  
   >>> a
5.  
   {'name': 'lcc', 'age': 18, 'job': 'techer', 'money': '1000', 'address': '涅阳路'}

3.字典的删除

del()：删除指定键值对

clear()：删除所有键值对

pop()：删除指定键值对，并返回对应的值对象

4.popitem()：随机删除和返回该键值对。字典无序可变，随机弹出。

1.  
   >>> a = {'name':'lcc','age':18,'job':'techer'}
2.  
   >>> a.popitem()
3.  
   ('job', 'techer')
4.  
   >>> a
5.  
   {'name': 'lcc', 'age': 18}
6.  
   >>> a.popitem()
7.  
   ('age', 18)
8.  
   >>> a
9.  
   {'name': 'lcc'}

（四）序列解包：用于列表、元祖、字典，方便对多个变量赋值。

序列解包用于字典时，默认对键操作；如果对键值操作items()；如果对值操作values()。

1.  
   >>> a = {'name':'lcc','age':18,'job':'techer'}
2.  
   >>> name,age,job=a #默认对键操作
3.  
   >>> name
4.  
   'name'
5.  
   >>> name,age,job=a.items() #对键值操作
6.  
   >>> name
7.  
   ('name', 'lcc')
8.  
   >>> name,age,job=a.values() #对值操作
9.  
   >>> name
10.  
    'lcc'

（五）表格数据使用字典和列表储存、数据访问

1.  
   r1 = {'name':'高小一','age':18,'salary':30000,'city':'北京'}
2.  
   r2 = {'name':'高小二','age':19,'salary':20000,'city':'上海'}
3.  
   r3 = {'name':'高小一','age':18,'salary':30000,'city':'北京'}
4.  
    
5.  
   tb = [r1,r2,r3]
6.  
    
7.  
   #获得第二行人的薪资
8.  
   print(tb[1].get('salary'))
9.  
    
10.  
    #打印表中所有的薪资
11.  
    for i in range(len(tb)): #i-->0,1,2
12.  
    print(tb[i].get('salary'))
13.  
     
14.  
    #打印表的所有数据
15.  
    for i in range(len(tb)):
16.  
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

（六）字典的核心底层原理（※）

字典对象的核心是散列表，稀疏数组。数组的每个单元叫bucket。

1.将键值对放进字典的底层过程

（1）假设数组长度为8，把键值对'name' = 'lcc'放在a中，首先要计算键的散列值：hash()

1.  
   >>> a = {}
2.  
   >>> a['name']='lcc'
3.  
   >>> bin(hash('name'))
4.  
   '0b10111010110011100110010111110101000101000001111111101101100001'

（2）由于数组长度为8，可用散列值右3位作为偏移量，即“101”，十进制是5，查看偏移量5，为空则放进去，若不为空，依次取右边3位作为偏移量，即“100”，十进制是4，查看偏移量4是否为空。

（3）接近2/3，数组会扩容，创造更大的数组，将原有内容拷贝到新数组中。

2.根据键查找键值对的过程

3.总结

（1）键必须可散列

①数字、字符串、元祖都是可散列的

②自定义对象需要支持下面三点

• 支持hash()函数
• 支持通过__eq__()方法检测相等性
• 若a==b为真，则hash(a)==hash(b)也为真

（2）字典在内存中开销巨大，典型的空间换时间

（3）键查询速度很快

（4）在字典里面添加新建可能导致扩容，导致散列表中键的次序变化，因此，不要在遍历字典的同时进行字典的修改。

二、集合

    集合是无序可变，元素不能重复。（集合底层是字典实现，集合中的所有元素都是字典中的键对象，因此不能重复且唯一）

（一）集合的创建和删除

1.{}：创建

2.add()：添加元素

3.set()：将列表、元祖等可迭代对象转为集合，如果存在重复，则只保留一个

4.remove()：删除指定元素；clear()：清空整个集合

（二）集合的相关操作：并、交、差

|、&、-；union()、intersection()、difference()

1.  
   >>> a = {1,3,'sxt'}
2.  
   >>> b = {'he','it','sxt'}
3.  
   >>> a|b #并
4.  
   {1, 3, 'it', 'sxt', 'he'}
5.  
   >>> a&b #交
6.  
   {'sxt'}
7.  
   >>> a-b #差
8.  
   {1, 3}
9.  
   >>> a.union(b) #并
10.  
    {1, 3, 'it', 'sxt', 'he'}
11.  
    >>> a.intersection(b) #交
12.  
    {'sxt'}
13.  
    >>> a.difference(b) #差
14.  
    {1, 3}

三、控制语句

    代码的组织方式

（一）选择结构

1.单分支结构

（1）if 条件表达式：

      语句/语句块

①条件表达式：可以是逻辑表达式，关系表达式，算术表达式等

②语句/语句块：可以是一条或多条语句，多条语句缩进必须一致

1.  
   a = input("请输入一个小于10的数字:")
2.  
    
3.  
   if int(a)<10:
4.  
   print(a)

（2）※条件表达式详解

   ① 在选择和循环结构中，条件表达式值为False的情况如下：

False、0、0.0空值None/空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空range对象、空迭代对象。其他为True。

1.  
   b = [] #列表作为条件表达式，空列，是False
2.  
    
3.  
   if b:
4.  
   print("空的列表是False")
5.  
    
6.  
   c = "False" #非空字符串，True
7.  
   if c:
8.  
   print("c")
9.  
    
10.  
    d = 0 #为零的整数作为表达式，False,无输出
11.  
    if d:
12.  
    print(d)
13.  
     
14.  
    e = 10
15.  
    if e:
16.  
    print(e)
17.  
     
18.  
    if 3<e<100: #连续判断
19.  
    print("3<e<100")

②条件表达式中，不能有赋值操作符“=”，会报错。

2.双分支选择结构

一般双分支结构及三元条件运算符

1.  
   s = input("请输入一个数字：")
2.  
    
3.  
   if int(s)<10:
4.  
   print("s是小于10的数字")
5.  
   else:
6.  
   print("s是大于等于10的数字")
7.  
    
8.  
   #测试三元条件运算符
9.  
   print("s是小于10的数字" if int(s)<10 else"s是大于等于10的数字")

3.多分支选择结构

1.  
   #测试多分支选择结构
2.  
    
3.  
   score = int(input("请输入分数："))
4.  
   grade = ""
5.  
    
6.  
   if score<60:
7.  
   grade = "不及格"
8.  
   elif score<80: #60<score<80
9.  
   grade = "及格"
10.  
    elif score<90:
11.  
    grade = "良好"
12.  
    else:
13.  
    grade = "优秀"
14.  
     
15.  
    print("分数是{0}，等级是{1}".format(score,grade))
16.  
     
17.  
    print("********************************************************")
18.  
     
19.  
    if(score>90): #使用完整的条件表达
20.  
    grade = "优秀"
21.  
    if(60<=score<80):
22.  
    grade = "及格"
23.  
    if(80<=score<90):
24.  
    grade = "良好"
25.  
    if(score<60):
26.  
    grade = "不及格"
27.  
    print("分数是{0}，等级是{1}".format(score,grade))

4.选择结构嵌套

    使用时控制好不同级别代码的缩进量，缩进决定代码从属关系。

1.  
   #测试选择结构的嵌套
2.  
   score = int(input("请输入一个0-100之间的数字："))
3.  
   grade = ""
4.  
   if score>100 or score<0:
5.  
   score = int(input("输入错误！请重新输入一个0-100之间的数字："))
6.  
   else:
7.  
   if score>=90:
8.  
   grade = "A"
9.  
   elif score>=80:
10.  
    grade = "B"
11.  
    elif score>=70:
12.  
    grade = "C"
13.  
    elif score>=60:
14.  
    grade = "D"
15.  
    else:
16.  
    grade = "E"
17.  
    print("分数是{0}，等级是{1}".format(score,grade))
18.  
     
19.  
    print(("***************************************************************************************"))
20.  
     
21.  
    score = int(input("请输入一个0-100之间的数字："))
22.  
    degrade = "ABCDE"
23.  
    num = 0
24.  
    if score>100 or score<0:
25.  
    score = int(input("输入错误！请重新输入一个0-100之间的数字："))
26.  
    else:
27.  
    num = score//10
28.  
    if num<6:num = 5
29.  
     
30.  
    print("分数是{0}，等级是{1}".format(score,degrade[9-num]))

（二）循环结构

1.while循环

1.  
   while num<=10:
2.  
   print(num,end="\t")
3.  
   num += 1
4.  
    
5.  
   print("************************************")
6.  
    
7.  
   #计算1-100之间数字的累加和
8.  
   num2 = 0
9.  
   sum_all = 0
10.  
     
11.  
    while num2<=100:
12.  
    sum_all = sum_all + num2
13.  
    num2 += 1
14.  
     
15.  
    print("1-100之间数字的累加和:",sum_all)