format格式化和元组,字典

新课标

可以用如下的方式，对格式进行进一步的控制：

%(name)[width].[precision]typecode

(name)为命名

flags可以有+,-,' '或0。+表示右对齐。-表示左对齐。' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。

width表示显示宽度

precision表示小数点后精度

例子：

>>> print("%+10x"% 10)
        +a
>>> print("%04d"%5)
0005
>>> print("%6.3f"%2.3)
 2.300
>>>
>>> print("%2.3f"%2300.2)
2300.200
>>>

format格式化

• 位置映射

  列子：

  >> "{}".format("珊")
  '珊'
  >>> "{}:{}".format("1","2")
  '1:2'
  >>> print("his name is {}".format("ww","q"))
  his name is ww
  >>> print("his name is {},his age is {}".format("ww","q"))
  his name is ww,his age is q
  >>>
  

• 关键字映射

  >>> print("{name},++++,{age},++++,{name}".format(name="xiaoming",age=18))
  xiaoming,++++,18,++++,xiaoming
  >>>
  

• 元素访问

  print("{0[0]}----{0[1]}----{1[1]}".format(["python","java"],["c++","R Language"]))
  python----java----R Language
  

  元组

  是一个有序，课重复的，不可更改的对象
  

  特点：
  	1.与list类似；
  	2.不可变类型数据；
  	3.元组使用的是（）
  

  元组的基本使用格式：

  （元素1，元素2，···，元素n）
  

  基本描述：

  ​ 元组是用（）包囊起来的多个元素的数据类型，每个元素之间用“，”隔开；

1，元组的创建

• 创建一个空元组

  >>> t1=()
  >>> type(t1)
  <class 'tuple'>
  >>>
  

• 创建只含有一个元素的元组

  需要注意的地方是：如果我们创建只含有一个元素的元组，我们必须在这仅有的一个元素后加一个“，”。

>>> t2=(6)
>>> t2,type(t2)
(6, <class 'int'>)
>>> t2=(6,)
>>> t2,type(t2)
((6,), <class 'tuple'>)
>>>

• 创建含有多个元素的元组

  >>> t1=(1,2,3,4,5,6)1
  

  和列表一样，元组的元素也可以是不同的数据类型的元素

2.元组的基本操作

查

• 通过查索引找到对应的元素

  >>> t3 = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
  >>> t3[4]
  {'name': 'Tom', 'age': 18}
  >>>
  >>> t3[-1]
  {'name': 'Tom', 'age': 18}
  >>> t3[::-2]
  ({'name': 'Tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)
  >>>
  

• 查找元素的索引值

t3 = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
print(t3.index("hunan"))
print(t3.index("hunan",1,4))
结果：
1
1

注意：元组是不可变的数据类型，不能够增，删，改

t4 = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
print(t4[0]=0)
不能更改，语法报错

注意到t4 里有个列表，那么这个列表中的元素是否可以更改：

>>> t4 = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
>>> t4[2]
['h', 'u', 'n', 'a', 'n']
>>> t4[2][2]='N'
>>> t4
(1, 'hunan', ['h', 'u', 'N', 'a', 'n'], ('I', 'love', 'python'), {'name': 'Tom', 'age': 18})
>>>

拼接

>>> t1=('a','b','c')
>>> t2=('d','e','f')
>>> t1+t2
('a', 'b', 'c', 'd', 'e', 'f')
>>>

重复

>>> t1*3
('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
>>>

判断元素是否存在

>>> t1=('a','b','c')
>>> 'a' in t1
True
>>> 'a' not in t1
False
>>>

内置函数（最大值最小值）

>>> t1=('a','b','c')
>>> max(t1)
'c'
>>> min(t1)
'a'
>>>

元组的遍历

1）值遍历

>>> tp=('python','java','c++')
>>> for i in tp:
...     print(i,end=" ")
...
python java c++ >>>

2.索引遍历

tp=('python','java','c++')
>>> for i in range(len(tp)):
...     print(tp[i],end=" ")
...
python java c++ >>>

3.索引-值，遍历

枚举（enumerate），对于一个可以迭代的（iterable）/可遍历的对象（如列表,字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

>>> tp=('python','java','c++')
>>> for index,value in enumerate(tp):
...     print(index,':',value)
...
0 : python
1 : java
2 : c
    
>>> tp=('python','java','c++')
>>> for index,value in enumerate(tp,6):
...     print(index,':',value)
...
6 : python
7 : java
8 : c++
>>>

二维元组

>>> tp=((1,2,3),(4,5,6),(7,8,9))
>>> tp[1][1]
5
>>>

三维元组

>>> tp=(((1,2,3),(4,5,6),(7,8,9)),)
>>> tp[0][1][1]
5
>>>

复习

>>> a=['a','b','c']
>>> b=['d','e','f']
>>> tuple(a)
('a', 'b', 'c')
>>> tuple(b)
('d', 'e', 'f')
>>> list(a)+list(b)
['a', 'b', 'c', 'd', 'e', 'f']
>>> a+b
['a', 'b', 'c', 'd', 'e', 'f']
>>> str(tuple(a))
"('a', 'b', 'c')"
>>> str(list(b))
"['d', 'e', 'f']"
>>>

• 字符串，元组为不可变数据类型

• 列表为可变列表

  作业

  demo:名片打印
  
  要求：输入姓名、年龄、工作和爱好，按下列格式输出：
  
      ---info of Linus---
      Name  :  Linus
      Age   :  18
      job   :  IT
      Hobbie:  Read
      -------end------
  
  作业：上述名片打印拓展成存储多人信息的列表。
  		[
  
  		["Linus", 18,  "IT", "Read"],
  
  		["Tom", 17, "IT", "Sing"],
  
  		....
  
  		]
  

字典

思考：

场景1

如果有列表

>>> li=['python','java','c++']

需要对"python"这个名字写错了，通过代码修改：

>>> li=['python','java','c++']
>>> li[0]='html'
>>> print(li)
['html', 'java', 'c++']

如果列表的顺序发生了变化，如下

>>> li=['python','java','c++']

此时就需要去修下标，才能完成名字的修改

>>> li=['python','java','c++']
>>> li[2]='python'
>>> print(li)
['python', 'java', 'python']

有没有方法，既能存储多个数据，还能在访问元素的很方便就能够定位到需要的那个元素呢？

答：

​ 字典

场景2

学生信息列表，每个学生信息包括学号，姓名，年龄等，如何从中找到某个学生的信息？

studens=[201801,'张山',18],[201802,'李四',19],[201803,'王二'17]

循环遍历？这样很麻烦。

实际生活中，我们还经常使用汉语字典，英汉字典等等

程序中的字典：

info={"usrname":"Lilei","age":18,"Class":"one"}

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。字典是一种可变数据类型，且可存储任意类型对象。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

格式：

​ {key:value1,key:value2,…}

描述：

1.健-值对中间用冒号(":")连接；

2.key：value组成字典里的一个元素；

3.健-值对（元素）之间用逗号（“，”）隔开；

4.整个字典用花括号“{}”包裹起来。

字典的创建

创建一个空字典

>>> dict=()
>>> type(dict)
<class 'tuple'>
>>>

创建一个有多个值的字典

1.直接能赋值法： d={key1:value1,key2:value2},如：

>>> info ={"username":"limei","age":18}
>>> info
{'username': 'limei', 'age': 18}
>>>

2，通过函数创建字典（强制转换）

列子：

方法1
>>> info = dict(usrname = "Lilei", age = 18, Class = "one")
>>> info
{'usrname': 'Lilei', 'age': 18, 'Class': 'one'}
方法2
>>> info = dict([['name', 'LiLei'], ['age', 18]])
>>> info
{'name': 'LiLei', 'age': 18}
方法3
>>> info = dict((('name', 'LiLei'), ('age', 18)))
>>> info
{'name': 'LiLei', 'age': 18}
方法4
>>> info = dict([('name', 'LiLei'), ('age', 18)])
>>> info
{'name': 'LiLei', 'age': 18}
方法2
5
>>> info = dict((['name', 'LiLei'], ['age', 18]))
>>> info
{'name': 'LiLei', 'age': 18}
>>>

3.通过字典的fromkeys方法创建字典

>>> info=dict.fromkeys("Hello")# 如果没有指定默认值，默认为None；
>>> info
{'H': None, 'e': None, 'l': None, 'o': None}
>>> info=dict.fromkeys(["lilei","lee","jack"],"123456")#
给每个元素设置默认值为“123456”
>>> info
{'lilei': '123456', 'lee': '123456', 'jack': '123456'}
>>>

字典的常见操作

字典值的访问（查的一种）

字典是无序的，不能通过索引来获取值。

>>> info=info[2]
Traceback (most recent call last):
  File "", line 1, in <module>
NameError: name 'info' is not defined
>>>

• 通过健（key）访问值（value）

  • key值不存在的时候，会报错

>>> info={"usename":"Lilei","age":18,"class":"one"}
>>> info["usename"]#通过关键字访问相对于的值
'Lilei'
>>> info["age"]
18
>>> info["usname"]#没有对应的key，报错
Traceback (most recent call last):
  File "", line 1, in <module>
KeyError: 'usname'
>>>

• 使用get访问值（value）

  不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

  • 当key不存在的，不会抛出异常。返回None。

>>> info={"name":"Lilei","age":18}
>>> info.get("name")
'Lilei'
#当key不存在的，不会抛出异常，返回None
>>> info.get("job")
>>> type(info.get("job"))

>>>

高照老 2019/3/26 11:25:35

增

- 直接添加新键-值对
在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素:

>>> info = {"name": "LiLei", "age": 18}
>>> info["job"]="it"
>>> info
{'name': 'LiLei', 'age': 18, 'job': 'it'}
>>>

dict.update(dict1)

把字典dic1的键/值对更新到dic里

- 当两个字典中的键不同时，把dic1的键值插入到dic中
- 当两个字典中存在相同键时，dic1覆盖dit的键值

dict.update(dict1)

把字典dic1的键/值对更新到dic里

• 当两个字典中的键不同时，把dic1的键值插入到dic中
• 当两个字典中存在相同键时，dic1覆盖dit的键值

#当两个字典完全不相同时
>>> info = {"name":"LiLei","age":18}
>>> info1 = {"job":"IT","salary":100000}
>>> info.update(info1)
>>> info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'salary': 100000}
>>> info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'salary': 100000}
>>> info1
{'job': 'IT', 'salary': 100000}
>>>

#当两个字典存在相同键时,会覆盖前面的键值
>>> info = {"name":"LiLei","age":18}
>>> info2 = {"name":"Tom","salary":10000}
>>> info.update(info2)
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}
>>>
>>> info2
{'name': 'Tom', 'salary': 10000}
>>>

删

• del dict[key]

  • 删除指定的元素/健-值对

  • 没有返回值

>>> info={'name':'tom','age':18,'salary':10000}
>>> del info["salary"]
>>> info
{'name': 'tom', 'age': 18}
>>>

• del dict

  • 删除整个字典

>>> info={"name":"lilei","age":18}
>>> del info
>>> info
Traceback (most recent call last):
  File "", line 1, in <module>
NameError: name 'info' is not defined
>>>

• dect.clear()

  • 清空整个字典

>>> info={"name":"lilei","age":18}
>>> info.clear()
>>> info
{}
>>>

• dict.pop(keys)

  • 删除指定健-值对

>>> info={'name':'tom','age':18,'salary':10000}
>>> info.pop("age")
18
>>> info
{'name': 'tom', 'salary': 10000}
>>>

• dict.popitem()

  • 随机删除字典中的一组健值对

  • 有返回值，咦元组方式返回

  • 应用不广泛

>>> info={'name':'tom','age':18,'salary':10000}
>>> info.popitem()
('salary', 10000)
>>> info
{'name': 'tom', 'age': 18}
>>>

改

字典的每个元素的数据是可以修改的，只要通过key找到，即可修改

• 直接修改

>>> info={'name':'tom','age':18,'salary':10000}
>>> info["name"]="lilei"
>>> info
{'name': 'lilei', 'age': 18, 'salary': 10000}
>>>

• dict.setdfault()

  • 健存在，不改动，返回字典中相应的值

  • 健不存在，在字典中添加相对应的键值对，并返回相应的值

#健存在，不改动，返回字典中相应的值
>>> info={'name':'tom','age':18,'salary':10000}
>>> info.setdefault("age",20)# 有返回值
18
>>> info
{'name': 'tom', 'age': 18, 'salary': 10000}

#健不存在，在字典中天机爱相应的键值对，并返回相应的值
>>> info={'name':'tom','age':18,'salary':10000}
>>> info.setdefault("job","it")
'it'
>>> info
{'name': 'tom', 'age': 18, 'salary': 10000, 'job': 'it'}
>>>

查

• dict.keys()
  • 返回字典中的所有健（keys）
• dict.value()
  • 返回 字典中的所有值（value）
• dict.litems()
  • 返回字典中的所有健-值对(keys-value)
• key in dict
  • 存在，True
  • 不存在，False

Python2中，可以用dict.has_key(),如果key在字典中，返回True；否则，返回False

>>> info={'name':'tom','age':18,'salary':10000}
>>> info.keys()
dict_keys(['name', 'age', 'salary'])
>>> info.values()
dict_values(['tom', 18, 10000])
>>> info.items()
dict_items([('name', 'tom'), ('age', 18), ('salary', 10000)])
>>> "age" in info
True
>>> "job" in info
False
>>>

字典的遍历

（1）遍历字典的健（key）

>>> info={"usrname":"lilei","age":18,"class":"one"}
>>> for key in info.keys()
  File "", line 1
>>> for key in info.keys():
...     print(key,end="")
...
usrnameageclass>>>

（2）遍历字典的值（value）

>>> info = {"usrname":"Lelei","age":18,"Class":"one"}
>>> for value in info.values():
...     print(value,end = " ")
...
Lelei 18 one >>>

（3）遍历所有的项（items）

>>> info = {"usrname":"Lelei","age":18,"Class":"one"}
>>> for item in info.items():
...     print(item,end = " ")
...
('usrname', 'Lelei') ('age', 18) ('Class', 'one') >>>

（4）遍历字典的键-值对(key-value)

>>> info = {"usrname":"Lelei","age":18,"Class":"one"}
>>> for key, value in info.items():
...     print(key,":",value,end = " ")
...
usrname : Lelei age : 18 Class : one >>>