python字典_集合_选择循环结构

1.字典

字典定义

字典是"键值对”的无序可变序列,字典中的每个元素都是-一个”键值对”, 包含: "键对象”和"值对象”。可以通过"键对象"实现快速获取、删除、更新对应的“值对象”。列表中我们通过“下标数字"找到对应的对象。字典中通过“键对象”找到对应的“值对象”。"键” 是任意的不可变数据,比如:整数、浮点数、字符串、元组。但是:列表、字典、集合这些可变对象,不能作为"键” 。并且"键” 不可重复。

"值”可以是任意的数据,并且可重复。

-个典型的字典的定义方式:

a = {'name':'zzz,'age':18,job'programmer'}

字典的创建

1.我们可以通过{}、dict(来创建字典对象。

>>> a = {'name':'zzz,'age':18,job'programmer'}

>>> b = dict(name='zzz',age= 18job= 'programmer')

2.通过zip0创建字典对象

>>> k = ['name'age',"job']

>>> v = ['gaoqi',18,'techer']

>>> d = dict(zip(k,v))

>>> d

{'name': 'gaoqi', 'age': 18, 'job': 'techer'}

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

>>> a = dict.fromkeys("'name'age'job'])

>>> a

{'name': None, 'age': None, 'job': None}

字典元素的访问

1.通过[键] 获得“值”。若键不存在,则抛出异常。

>>> a = {'name':'zzz','age':18,'job':' programmer'}

>>> a['name']

'gaoqi'

2.通过get()方法获得"值" .推荐使用。优点是:指定键不存在,返回None ;也可以设定指定键不存在时默认返回的对象。推荐使用get0获取“值对象”。

3.列出所有的键值对

>>> a.items(）

4.列出所有的键,列出所有的值

>>> a.keys()

dict_ keys('name'; 'age', 'job'])

>>> a.values()

dict values(['zzz', 18, 'programmer'])

5. len0 键值对的个数

6.检测一个"键”是否在字典中

>>> a = {"name":"zzzi"," age" :18}

>>> " name" in a

True

字典元素添加、修改、删除

1.给字典新增”键值对"。如果"键” 已经存在,则覆盖旧的键值对;如果"键”不存在,则新增”键值对”。

2.使用update0将新字典中所有键值对全部添加到旧字典对象上。如果key有重复,则直接覆盖.

3.字典中元素的删除，可以使用del0方法;或者clear0删除所有键值对; pop0删除指定键值对,并返回对应的“值对象”;

>>> a = {'name':gaqi','age'18,"job:'programmer}

>>> del(a['name'])

>>> a

{'age': 18, 'job': 'programmer'}

4. popitem()  :随机删除和返回该键值对。字典是“无序可变序列”, 因此没有第一个元素、最后一个元素的概念; popitem弹出随机的项,因为字典并没有"最后的元素"或者其他有关顺序的概念。若想-个接一个地移除并处理项 ,这个方法就非常有效(因为不用首先.获取键的列表)。

序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值.

>>> x,y,z= (20,30,10)

>>>x

20

>>> (a,b,c)=(9,8,10)

>>> a

9

>>> [a,b,c]=[10,20,30]

>>>a

10

序列解包用于字典时，默认是对"键”进行操作;如果需要对键值对操作,则需要使用items( ; 如果需要对"值”进行操作,则需要使用values() ;

>>> s ={name:zzz; age':18, job':student'}

>>> name,agejob= s.items()        #对键值对进行操作

>>> name

('name', 'zzz')

>>> name,agejob= s.values()        #对值进行操作

>>>name

zzz

字典核心底层原理

字典对象的核心是散列表。散列表是-一个稀疏数组(总是有空白元素的数组) , 数组的每个单元叫做bucket.每个bucket有两部分: -一个是键对象的引用, -一个是值对象的引用。

由于，所有bucket结构和大小一致，我们可以通过偏移量来读取指定bucket.

将一个键值对放进字典的底层过程

假设字典a对象创建完后,数组长度为8 :

我们要把”name" =”zzz" 这个键值对放到字典对象a中，首先第1步需要计算键”name”的散列值。Python 中可以通过hash()来计算。由于数组长度为8 ,我们可以拿计算出的散列值的最右边3位数字作为偏移量,即”101”， 十进制是数字5。我们查看偏移量5 ,对应的bucket是否为空。如果为空,则将键值对放进去。如果不为空,则依次取右边3位作为偏移量,即“100”, 十进制是数字直到找到为空的bucket将键值对放进去。

查找值对象过程类似

用法总结

1.键必须可散列

        (1)数字、字符串、元组,都是可散列的。

        (2)自定义对象需要支持下面三点: 

                  1.支持hash()函数

                  2.支持通过eq_ 0方法检测相等性。

                  3.若a==b为真,则hash(a)= =hash(b)也为真。

2.字典在内存中开销巨大,典型的空间换时间。

3.键查询速度很快

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

2.集合

集合是无序可变,元素不能重复。实际上,集合底层是字典实现,集合的所有元素都是字典中的"键对象”, 因此是不能重复的且唯一-的。

集合的创建和删除

1.使用{}创建集合对象,并使用add0方法添加元素

>>> a = {3,5,7}

>>> a

{3, 5, 7}

>>> a.add(9)

>>> a

{9,3, 5, 7}

2.使用set() ,将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据,则只保留一个。

>>> a= ['a'',b','c','d']

>>> b = set(a)

>>> b

{"b', 'a', 'c'}

3. remove(删除指定元素; clear()清空整个集合

>>> a = {10,20,30,40,50}

>>> a.remove(20)

>>> a

{10, 50, 30}

集合相关操作

像数学中概念-样, Python对集合也提供了并集、交集、差集等运算。

>>>a = {1,3,'sxt'}|
>>> b = {'he't,'sxt'}
>>> a|b    #并集
{1, 3, 'sxt', 'he', 'it'}
>>> a&b    #交集
{'sxt'}
>>> a-b    #差集
{1, 3}
>>> a.union(b)    #并集
{1,3, 'sxt', 'he', 'it'}
>>> a.intersection(b)    #交集
{'sxt'} 
>>> a.difference(b)    #差集
{1,3}

选择结构

选择结构通过判断条件是否成立,来决定执行哪个分支。选择结构有多种形式,分为: 单分支、双分支、多分支。

单分支选择结构

if语句单分支结构的语法形式如下:

        if条件表达式:

                语句/语句块

其中:①.条件表达式:可以是逻辑表达式、关系表达式、算术表达式等等。

        ②.语句/语句块:可以是一条语句 ,也可以是多条语句。多条语句,缩进必须对齐-致。

操作输入一个数小于10则打印这个数

num = input("输入-个数字: ")
if int(num)<101
    print(num)

条件表达式详解

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

        False、0、0.0、 空值None、空序列对象(空列表、空元祖、空集合、空字典、空字符串)、空range对象、空迭代对象。其他情况,均为True.这么看来, Python所有的合法表达式都可以看做条件表达式,甚至包括函数调用的表达式。

操作测试各种条件表达式

if 3:     #整数作为条件表达式
    print("QK")
a= 0     #列表作为条件表达式，由于为空列表,是False
if a:
    print("空列表, False")
s = "False"     #非空字符串,是True
if s:
    print("非空字符串,是True")
c=9
if3<c<20:
    print("3<c<20")
if3<c and c<20:
    print("3<C and c<20")
if True:    #布尔值
print("True")

条件表达式中,不能有赋值操作符“="

在Python中,条件表达式不能出现赋值操作符"=”, 避免了其他语言中经常误将关系运算符“==”写作赋值运算符"=” 带来的困扰。

双分支选择结构

双分支结构的语法格式如下:

if    条件表达式:

        语句1/语句块1

else:

        语句2/语句块2

操作输入-个数字,小于10 ,则打印该数字;大于10 ,则打印“数字太大”

num = input("输入一个数字: ")
if int(num) <10:
    print(num)
else:
    print("数字太大")

三元条件运算符

Python提供了三元运算符,用来在某些简单双分支赋值情况。三元条件运算符语法格式如下:

                条件为真时的值 if  (条件表达式)   else   条件为假时的值

num = input("请输入-个数字")
print( num if int(num) < 10 else "数字太大")

多分支选择结构

多分支选择结构语法格式如下

操作输入-一个学生的成绩,将其转化成简单描述:不及格(小于60)、及格(60-79)、良好(80-89)、优秀(90-100)。

#测试多分支选择结构
score = int(input("请输入分数："))
grade = ""
if score<60:
    grade = "不及格"
elif score<80:
    grade = "及格"
elif score<90:
    grade = "良好"
else:
    grade ="优秀"

print("分数是{0}，等级是{1}".format(score,grade))

 选择结构嵌套

选择结构可以嵌套,使用时- -定要注意控制好不同级别代码块的缩进量因为缩进量决定了代码的从属关系。语法格式如下:

操作输入-一个分数。分数在0-100之间。90以上是A,80以上是B, 70以上是C, 60 以上是D。60以下是E.

#测试选贼结构的嵌套
score = int(input("请输入一个在0~100之间的数字"))
grade = ""
if score>100 or score<0:
    score = int(input("输入错误！请重新输入一个数字"))
else:
    if score>=90:
        grade = "A"
    elif score>=80:
        grade = "B"
    elif score>=70:
        grade = "C"
    elif score>=60:
        grade = "D"
    else:
        grade = "E"
        print("分数为{0}，等级为{1}".format(score,grade))

循环结构

循环结构用来重复执行一条或多条语句。 表达这样的逻辑:如果符合条件, 则反复执行循环体里的语句。在每次执行完后都会判断一-次条件是否为 True ,如果为True则重复执行循环体里的语句。图示如下：

                                        

 循环体里面的语句至少应该包含改变条件表达式的语句, 以使循环趋于结束;否则,就会变成一个死循环。

while循环

while循环的语法格式如下:

while  条件表达式:

        循环体语句

操作

#测试while循环
num = 0
while num<10:
    print(num,end="\t")
    num += 1
#计算1-100之间的数字的累加和
num2 = 0
sum_all = 0
while num2<=100:
    sum_all = sum_all + num2
    num2 += 1
print("1-100所有书累加和：",sum_all)