秃头的一天

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

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

   示例（命令行下）：

   >>>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的键，而不是值.

2. 针对楼上的 字典 拓展，做测试的时候，想要输出 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类型，所以 用+ 号会出问题。

3. 在list的使用中，开始时很容易忽视的一点是：

   list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
   print (list[1:3])       # 从第二个开始输出到第三个元素

   list[1:3] 其实输出的只有两个变量，即list中第二个元素到第三个元素，并不是第1 第2 第3三个元素，而且要注意的是

   print (list[2])
   print (list[2:3])

   这两句话打印的内容其实是一样的，

   2.23
   [2.23]

   但是第二句话有中括号

   list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
   print (list[1:3])       # 从第二个开始输出到第三个元素
   # 获得结果 [786, 2.23]

   其实我觉得可以这样理解：

   print (list[1:3])       # 从数组下标为1的数开始获取直到数组下标为3（但不包含3）的数为止，输出这段
   # 获得结果 [786, 2.23]

   其实我们可以试验一下：

   print (list[1:0])       # 没有输出的值
   # 获得结果 []
   
   print (list[1:1])       # 没有输出的值
   # 获得结果 []
   
   print (list[0:1])       # 没有输出的值
   # 获得结果 ['abcd']

   其实中括号里的值还可以为负数：

   >>> print(arrtest[1:-1])    # 从下标为1的数开始，输出到下标为4但不包含4的所有值
   [786, 2.23, 'runoob']
   >>> print(arrtest[-3:-2])   # 从下标为2的数开始，输出到下标为3但不包含3的所有值
   [2.23]

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

   list 补充:

   list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
   print (list[2])
   print (list[2:3])

   这两句话打印的内容其实是一样的:

   2.23
   [2.23]

   但注意是不同的类型，用变量接收一下：

   a = list[2]
   b = list[2:3]
   type(a) -> <class 'float'>
   type(b) -> <class 'list'>

4. python 与 C 语言和 Java 语言的一点不同，表现在它的变量不需要声明变量类型，这是因为像 C 语言和 Java 语言来说，它们是静态的，而 python 是动态的，变量的类型由赋予它的值来决定，例如：

   >>> a = 1
   >>> a = 1.001
   >>> a = "python"
   >>> print(a)
   python
   >>>

   第一次为变量 a 赋值为整型，第二次赋值是浮点数，第三次是一个字符串，最后输出时只保留了最后一次的赋值。

5. 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'>

6. 字典（小拓展）

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

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

7. 字典（小拓展）

   原文说 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}

8. 集合与字典

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

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

9. #coding=utf8  
   ''''' 
   复数是由一个实数和一个虚数组合构成，表示为：x+yj 
   一个负数时一对有序浮点数(x,y)，其中x是实数部分，y是虚数部分。 
   Python语言中有关负数的概念： 
   1、虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数 
   2、复数由实数部分和虚数部分构成 
   3、表示虚数的语法：real+imagej 
   4、实数部分和虚数部分都是浮点数 
   5、虚数部分必须有后缀j或J 
    
   复数的内建属性： 
   复数对象拥有数据属性，分别为该复数的实部和虚部。 
   复数还拥有conjugate方法，调用它可以返回该复数的共轭复数对象。 
   复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数） 
   '''  
   class Complex(object):  
       '''''创建一个静态属性用来记录类版本号'''  
       version=1.0  
       '''''创建个复数类，用于操作和初始化复数'''  
       def __init__(self,rel=15,img=15j):  
           self.realPart=rel  
           self.imagPart=img  
            
       #创建复数  
       def creatComplex(self):  
           return self.realPart+self.imagPart  
       #获取输入数字部分的虚部  
       def getImg(self):  
           #把虚部转换成字符串  
           img=str(self.imagPart)  
           #对字符串进行切片操作获取数字部分  
           img=img[:-1]   
           return float(img)    
                            
   def test():  
       print "run test..........."  
       com=Complex()  
       Cplex= com.creatComplex()  
       if Cplex.imag==com.getImg():  
           print com.getImg()  
       else:  
           pass  
       if Cplex.real==com.realPart:  
           print com.realPart  
       else:  
           pass  
       #原复数  
       print "the religion complex is :",Cplex  
       #求取共轭复数  
       print "the conjugate complex is :",Cplex.conjugate()  
         
   if __name__=="__main__":  
       test()

10. 切片还可以设置步长

    demo = [1,2,3,4,5,6]
    
    new_demo = demo[1::2]  # 2 就是步长 意思是从索引为 1 的元素开始 每隔2个元素取一次元素
    new_demo = [2,4,6] 
    
    # 以索引为列  [索引] 和 [索引:索引:步长] 的区别
    # demo[索引] 取出的原列表中索引对应的元素
    # demo[索引:索引:步长] 切片得到的是一个新列表

11. bool 型

    Python 中布尔值使用常量 True 和 False 来表示。

    1、在数值上下文环境中，True 被当作 1，False 被当作 0，例如：

    >>> True+3
    4
    >>> False+2
    2

    2、其他类型值转换 bool 值时除了 ''、""、''''''、""""""、0、()、[]、{}、None、0.0、0L、0.0+0.0j、False 为 False 外，其他都为 True 例如：

    >>> bool(-2)
    True
    >>> bool('')
    False

    函数的参数为多个时，不一定是以元组的形式返回的，还是要看自己定义的返回形式是什么:

12. >>> def example(a,b):
    ...     return (a,b)
    ... 
    >>> type(example(3,4))
    <type 'tuple'>
    >>> def example(a,b):
    ...     return a,b
    ... 
    >>> type(example(3,4))
    <type 'tuple'>
    >>> def example(a,b):
    ...     return [a,b]
    ... 
    >>> type(example(3,4))
    <type 'list'>
    >>> type(example(3,4))
    <type 'tuple'>
    >>> def example(a,b):
    ...     return [a,b]
    ... 
    >>> type(example(3,4))
    <type 'list'>

    以上实际返回值也只有一个，一个 List 类型的参数。

    一楼所说的返回值为多个是：

    >>> type(example(3,4))
    <type 'tuple'>
    >>> def example(a,b):
    ...     return a,b
    ... 
    >>> type(example(3,4))
    <type 'tuple'>

13. Bool 型小知识 :

    • Python2 支持：int、float、long、complex（复数）
    • Python3 支持：int、float、bool、complex（复数）

    Python3 废除了 long 类型，将 0 和 1 独立出来组成判断对错的 Bool 型，即 0 和 1 可以用来判断 flase 和 true。但是根本上并没有修改原则。这里的 Bool 型依然是 int 型的一部分，所以依然能当做数字参与运算，所以 Python3 里的 Bool 型是 int 型的一个特例而不是一个独立的类型。

14. 注意：列表、元组、集合有所区别(新人特别容易入坑)。

    列表和元组不会把相同的值合并，但是集合会把相同的合并。

    >>> clist = ['tom','tom','jerry']                #测试列表功能
    >>> print (clist）
    ['tom','tom','jerry']
    
    >>>ctuple = ('tom','tom','jerry')           #测试元组功能
    >>>print(ctuple)
    ('tom','tom','jerry') 
    
    >>>cset = {'tom','tom','jerry'}                #测试集合功能
    >>>print(cset)
    {'tom','jerry'}

15. 关于列表的创建细节补充：

    >>> o = {1, 2, 3}
    >>> type(o)
    <class 'set'>
    >>> o = {}
    >>> type(o)
    <class 'dict'>

16. 关于字典推导式的一些案例：

    '''

    # 字典推导式
    p = {i:str(i) for i in range(1,5)}
    print("p:",p)
    '''
    p: {1: '1', 2: '2', 3: '3', 4: '4'}
    '''
    
    x = ['A','B','C','D']
    y = ['a','b','c','d']
    n = {i:j for i,j in zip(x,y)}
    print("n:",n)
    '''
    n: {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}
    '''
    
    s = {x:x.strip() for x in ('he','she','I')}
    print("s:",s)
    '''
    s: {'he': 'he', 'she': 'she', 'I': 'I'}
    '''

17. 所有数据类型都是类。

    也就是说，int、str等数据类型不是函数，只是一个类罢了。

    用int()、str()、list()等都是初始化相应的类，那么123456、"Runoob“、[1,2,3] 等都是相应数据类型的初始化结果。

    有很多人和教学网站都认为int、str、list等数据类型都是函数，但这是错误的。type(int)的输出结果表明int是一个类。

标签：一天,list,dict,复数,print,type,example,秃头
来源： https://www.cnblogs.com/15184742286LH/p/14054322.html