python笔记7 - 元组，字典

2017/10/10

元组，字典

 ==================================================================================================

 

元组 tuple

元组是不可改变的序列（像字符,元素个数和元素数据能够保证其可靠性），同list一样，元组可以存放任意的值

 

(1)表示方法：

  小括号()括起来

  单个元素括起来后加逗号(,)区分单个对象还是元组

 

(2)创建空元组

  t = ()        #空元组

  t = tuple()   #空元组

 

创建一个非空的元组

t = (20,)   >>>(20,)     含有一个元素的元组

t =  20,    >>>(20,)     含有一个元素的元组

t = (1,2,3) >>>(1,2,3)   含有三个元素的元组

t = 1,2,3

t = 'hello',

t = ('1',2,'tree')

 

创建元组错误实例（实际是序列赋值）：

t = (20)    >>>20

创建元组错误实例（实际是序列赋值）：       

x,y = 100,200     #x绑定100，y绑定200，这是序列赋值

x,y = (100,200)   #元组会拆开，分别赋值给x，y，x绑定100，y绑定200，这也是序列赋值

x,y = [100,200]   #x绑定100，y绑定200，这是序列赋值

x,y = "AB"        #这是序列赋值

 

 

 

(3)元组的构造（生成）函数tuple

tuple()     生成一个空元组

tuple(iterable)    用可迭代对象生成一个元组

实例：

tuple("abcd")

tuple([1,2,3])

tuple(("q","c"))

 

元组的运算：

    算数运算:+  +=  *  *=

    +   拼接

    +=  拼接后对变量赋值

    *   生成重复的元组

    *=  生成重复的元组并赋值给变量

实例：

    x = (1,2,3) + (4,5,6)

    x += (7,)

    x = (1,2)

    x *= 3

 

比较运算：

<<=  >>=  ==  !=

    (1,2,3) < (1,2,4)   #True

    x = (1,2,3)

    y = 1,3,2

    x != y  #True

    x == y  #False

    y > x   #True

 

元组的 in / not in 运算符

  同字符串和列表的in运算符相同，用于判断一个值是否存在于元组中，存在返回True，不存在返回False

实例：

x = (1,"two",3.1)

2 in x           #False

"2" not in x     #True

 

索引 index

    等同于字符串的索引规则

    元组不能索引赋值

    t = (1,2,3)

    t[0]              

 

切片 slice

    等同于字符串的切片规则

    元组不能切片赋值

 

可用于序列的函数总结：

len(s)

max(x)

min(s)

sum(x)

any(x)

all(x)

reversed(seq)    返回反向顺序的迭代器,是全局的函数

sorted（iterable,key=None,reverse=False）返回已排序的列表

实例：

s = 'ABC'

for x in reversed(s):

    print(x)

 

s = "AMCBJ"

sorted(s)    #['A','B','C','J','M']

ss = ''.join(sorted(s))

 

t = (8,3,6,2,7)

sorted(t,)

sorted(t,reverse=True)

 

 

元组的方法：

T.index(v[,begin[,end]]) 返回对应元素的索引下标，begin为开始索引，end为结束索引（不包含end）

T.count(x)   返回元组中对应元素的个数

 

 

------------------------------------------------------------------------------------------------------------

 

1.字典 dict:字典是一种可变的容器，可以存储任意类型的数据

2.字典中每个数据都是用"键"（key）进行索引，而不像序列可以用下标进行索引

3.字典中的数据没有先后关系，字典的存储是无序的

4.字典的数据是以键(key) - 值（value）对的形式进行存储的

5.字典的表示方法是以{}括起来，以冒号(:)分割的键值对，各键值对之间用逗号隔开

6.字典的键不能重复

7.字典的优势：在数据结构中，在庞大的数据流中，能迅速定位数据的位置，找到想要的数据，字典的优点是查找，删除，插入的速度快

 

(1)创建空字典的方法：

  d = {}      #空字典  

  d = dict()  #空字典

 

(2)创建非空字典的方法：

实例1：

  d = {"name":"xiaoyu","age":22}

  说明："name":"xiaoyu"为一个键值对，各个键值对之间用逗号隔开，各个键值对内用冒号表示索引

  字典取值：d['name']  >>>"xiaoyu"

实例2：

  d = {"name":"xiaoyu","name":22}  #这个不会报错，但是会留下唯一一个“键”（随机删除重复的键），留下后一个对应“22”的键

 

(3)字典的值(value)可以为任意类型:

字典的值可以是布尔值，数据，字符串，None，列表，元组，字典，以及后面要学到的集合，函数，类对象等所有类型

实例：

  {"a":100}

  {"a":"abc"}

  {"a":True}

  {"a":"None}

  {"a":[1,2,3]}      放列表

  {"a":(1,2,3)}      放元组

  {"a":{"aa":11}}    放字典

 

说明：字典的键(key)必须为不可变类型的值：

不可变类型，即可以充当键的类型：None(特殊),bool,int,float,complex,str,tuple，frozenset(固定集合)

不能充当键的类型：列表，字典，集合

实例：

  {"a","a"}

  {100,"100"}

  {True,"True"}

  {"None","abc"}

  {(1907,1,1):"computer year!"}

 

(4)字典的基本操作：

字典的访问：用[]访问字典内的成员 字典[键]

实例：

  d = {"name":"tarena","age":15}

  print("姓名：",d["name"],"年龄：",d["age"])

 

(5)添加/修改字典的元素： 字典[键]=值

实例：

    d = {}

    d['name'] = 'tarena'    #创建新的键值对

    d['age'] = 15           #创建新的键值对

    d['age'] = 16           #修改age键对应的值

                            #插入键后，打印出的字典中键出现的顺序是随机的@@@@@@@@@@@@

键不存在时创建键，并绑定键对应的值，键存在时，修改键绑定的值

 

(6)删除字典元素 del

   del 字典[键]

实例：

d = {}

d['name'] = 'tarena'  >>>{'name': 'tarena'}

d['age'] = 15         >>>{'name': 'tarena', 'age': 15}

del d['age']          >>>{'name': 'tarena'      #删除年龄和其对应的值

 

(7)获取字典中元素(指键值对的个数)个数：len函数

   len(字典) 返回字典中元素(指键值对的个数)个数

实例：

len(d)

 

(8)字典的成员资格判断 in / not in 运算符

    可以用 in / not in 运算符来判断一个键是否存在于字典中，如果存在则返回True，否则返回False

实例：

d = {"name":"tarena","age":15}

"age" in d  #True

15 in d     #False   只判断键，不判断值（键不能重复，但是值是可以重复的）

 

(9)字典的生成函数：

dict()    生成一个字典，等同于{}

dict(iterable)    用可迭代对象初始化一个字典(列表就是一个可迭代对象)

dict(**kwargs)    关键字参数形式生成一个字典

实例：

d = dict()

d = dict([('name','tarena'),('age',15)]) #可迭代对象是个列表，元素是两个元组，可以返回 一个字典

d = dict(name="tarena",age=16)

 

name = 'xiaoyu'

{'name':xiaoyu}

 

(10)字典的方法字典推导式：

D代表字典对象

D.clear()    清空字典

D.pop(key)   移除键，同时返回此键对应的值

D.copy()     返回字典D的副本，只复制一层（浅拷贝）

D.update(D2) 将字典D2合并到D中，如果键相同，则此键的值取D2的值作为新值

D.get(key,default)  返回键key所对应的值，如果没有此键则返回default@@@@@@@@@@@@@@@@@@@@@@@@@

D.keys()     返回可迭代的dict_keys集合对象

D.valuas()   返回可迭代的dict_values集合对象

D.items()    返回可迭代的dict_items集合对象

 

 

实例：

d = {1:"1",2:"2"}

d2 = {1:"2.2",3:"3.3"}

d.update(d2)           >>>{1: '2.2', 2: '2', 3: '3.3'}

d.keys()

dict_keys([1, 2, 3])  #生成了可迭代对象，这样就可以进行for遍历,可以当做列表

 

for k in d.keys():

    print(k)          #1 2 3  打印键

for v in d.values():

    print(v)          #2.2   2   3   打印所有的值

 

d.items()             #在不知道键的个数的情况下使用

>>>dict_items([(1, '2.2'), (2, '2'), (3, '3.3')])

 

for i in d.items():

    print(i)

结果如下(打印出的是一系列元组，指的是变量列表)：

(1,'1')

(2,'2.2')

(3,'3.3')

 

for k,v in d.items():

    print('键',k,'--->',v)

>>>

键 1 --> 2.2

键 2 --> 2

键 3 --> 3.3

 

 

(11)字典推导式：

语法：

    {键表达式：值表达式 for 变量 in 可迭代对象 （if条件表达式）}

实例：

numbers = [1001,1002,1003,1004]

names = ["Tom","Jerry","Spike","Tyke"]

animals = { numbers[i]:names[i] for i in range(4) }  #i = 0 1 2 3

print(animals)    

>>>{1001: 'Tom', 1002: 'Jerry', 1003: 'Spike', 1004: 'Tyke'}

 

animals = { numbers[i]:names[i] for i in range(4) if numbers[i] % 2 == 0 }

>>>{1002: 'Jerry', 1004: 'Tyke'}

 

 

------------------------------------------------------------------------------------------------------------

 

练习：

1.字符串"hello",生成新字符串"h e l l o"和"h-e-l-l-o"

解法1：

L1 = list("hello")    #生成列表，列表中每个元素都是单独的字符

L2 = ' '.join(L1)

L3 = '-'.join(L2)

print(L2)

print(L3)

 

解法2：

s = "hello"

print(' '.join("hello"))

print('-'.join("hello"))   #字符串本身就是可迭代的

 

--------------------------------------------------------------

 

2.输入任意一个字符串或数字，判断是否为回文数

  12321     回文数

  ABCDCBA   回文

  abccba    回文

 

解法1：

s=input("输入一个数或字符串：")

n=len(s)//2

for x in range(0,n+1):

    if s[x] != s[-(x+1)]:

        print("不是回文！")

        break

else:

    print("是回文")

 

解法2：

L = list(s)

L2 = list(reversed(s))

if L==L2:

    print("是回文")

else:

    print("不是回文")

 

方法3:

if s == s[::-1]:

    print("是回文")

else:

    print("不是回文")

 

--------------------------------------------------------------

 

3.编写程序，获取一个数值，计算并发音其中每个数字出现个数

 如：键入2234524

     打印如下:

              数字2出现3次

              数字3出现1次

              数字4出现2次

              数字5出现1次

解法1：

exist = []  #已访问过的列表

s = input("请输入一串数字：")

for x in s:

    if x in exist:

        pass

    else:

        print(x,'出现',s.count(x),'次')

        exist.append(x)

 

解法2：

exist = []

s = input("请输入一串数字：")

for x in s:

    if x not in exist:

        print(x,'出现',s.count(x),'次')

        exist.append(x)

 

解法3：

s = input("请输入一串数字：")

for x in range(10):

    if str(x) in s:

        print(x,'出现',s.count(str(x)),'次')

 

--------------------------------------------------------------

 

4.已知两个等长的列表list1和list2，以list1中的元素为键，以list2中的元素为值，生成相应字典

如：

list1 = ["a","b","c"]

list2 = [1,2,3]

生成字典为:{'a': 1, 'b': 2, 'c': 3}

 

解：

list1 = ["a","b","c"]

list2 = [1,2,3]

A = { list1[i]:list2[i] for i in range(3) }

print(A)

>>>{'a': 1, 'c': 3, 'b': 2}