python 1.3*

针对楼上的字典拓展，做测试的时候，想要输出 kye:value的组合发现可以这样：
```
for c in dict:
    print(c,':',dict[c])
```
或者
```
for c in dict:
    print(c,end=':');
    print(dict[c])
```
于是发现 print()函数其实可以添加多个参数，用逗号隔开。

本来想要用
```
for c in dict:
    print(c+':');
    print(dict[c])
```
这样的方式打印 key：value结果发现其实 key不一定是 string类型，所以用+ 号会出问题。
在list的使用中，开始时很容易忽视的一点是：
```
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
```
```
print (list[2])
print (list[2:3])
```
这两句话打印的内容其实是一样的，
```
2.23
[2.23]
```
但是第二句话有中括号
type 是用于求一个未知数据类型对象，而 isinstance 是用于判断一个对象是否是已知类型。

type 不认为子类是父类的一种类型，而isinstance会认为子类是父类的一种类型。

可以用 isinstance 判断子类对象是否继承于父类，type 不行。

综合以上几点，type 与 isinstance 虽然都与数据类型相关，但两者其实用法不同，type 主要用于判断未知数据类型，isinstance 主要用于判断 A 类是否继承于 B 类：
```
# 判断子类对象是否继承于父类
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print (type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))
```
运行结果：
```
False
True
<class '__main__.son'>
<type 'type'>
```

字典（小拓展）

输入 dict 的键值对，可直接用 items() 函数：

dict1 = {'abc':1,"cde":2,"d":4,"c":567,"d":"key1"}
for k,v in dict1.items():
    print(k,":",v)

字典（小拓展）

原文说 dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。

其实d不一定必须为一个序列元组，如下：

>>> dict_1 = dict([('a',1),('b',2),('c',3)]) #元素为元组的列表
>>> dict_1
{'a': 1, 'b': 2, 'c': 3}
>>> dict_2 = dict({('a',1),('b',2),('c',3)})#元素为元组的集合
>>> dict_2
{'b': 2, 'c': 3, 'a': 1}
>>> dict_3 = dict([['a',1],['b',2],['c',3]])#元素为列表的列表
>>> dict_3
{'a': 1, 'b': 2, 'c': 3}
>>> dict_4 = dict((('a',1),('b',2),('c',3)))#元素为元组的元组
>>> dict_4
{'a': 1, 'b': 2, 'c': 3}

集合与字典

无序：集合是无序的，所以不支持索引；字典同样也是无序的，但由于其元素是由键（key）和值（value）两个属性组成的键值对，可以通过键（key）来进行索引

元素唯一性：集合是无重复元素的序列，会自动去除重复元素；字典因为其key唯一性，所以也不会出现相同元素
元组（小拓展）

一般来说，函数的返回值一般为一个。

而函数返回多个值的时候，是以元组的方式返回的。

示例（命令行下）：
```
>>>def example(a,b):
...     return (a,b)
...
>>>type(example(3,4))
<class 'tuple'>
>>>
```
python中的函数还可以接收可变长参数，比如以 "*" 开头的的参数名，会将所有的参数收集到一个元组上。

例如：
```
def test(*args):
    print(args)
    return args

print(type(test(1,2,3,4)))    #可以看见其函数的返回值是一个元组
```
字典（小拓展）

python中的字典是使用了一个称为散列表（hashtable）的算法（不具体展开），

其特点就是：不管字典中有多少项，in操作符花费的时间都差不多。

如果把一个字典对象作为for的迭代对象，那么这个操作将会遍历字典的键：
```
def example(d):
    # d 是一个字典对象
    for c in d:
        print(c)
        #如果调用函数试试的话，会发现函数会将d的所有键打印出来;
        #也就是遍历的是d的键，而不是值.
```
针对楼上的字典拓展，做测试的时候，想要输出 kye:value的组合发现可以这样：
```
for c in dict:
    print(c,':',dict[c])
```
或者
```
for c in dict:
    print(c,end=':');
    print(dict[c])
```
于是发现 print()函数其实可以添加多个参数，用逗号隔开。

本来想要用
```
for c in dict:
    print(c+':');
    print(dict[c])
```
这样的方式打印 key：value结果发现其实 key不一定是 string类型，所以用+ 号会出问题。
```
>>> a = 1
>>> a = 1.001
>>> a = "python"
>>> print(a)
python
>>> 
```
python 与 C 语言和 Java 语言的一点不同，表现在它的变量不需要声明变量类型，这是因为像 C 语言和 Java 语言来说，它们是静态的，而 python 是动态的，变量的类型由赋予它的值来决定，例如上例。第一次为变量 a 赋值为整型，第二次赋值是浮点数，第三次是一个字符串，最后输出时只保留了最后一次的赋值。

元组（小拓展）

字典（小拓展）

猜你喜欢