python数据类型（二）

一。List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号([])之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

实例

#!/usr/bin/python3 list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] tinylist = [123, 'runoob'] print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

>>> a = ['1','2','3','4']
>>> a[0]= 0
>>> print(a)
[0, '2', '3', '4']
>>> a[0:2]
[0, '2']
>>> a[:2]=[]
>>> a
['3', '4']
>>>

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

注意：

  • 1、List写在方括号之间，元素用逗号隔开。
  • 2、和字符串一样，list可以被索引和切片。
  • 3、List可以使用+操作符进行拼接。
  • 4、List中的元素是可以改变的。

二。Tuple元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

 

 

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

 

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

 

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

 

string、list和tuple都属于sequence（序列）。

 

注意：

 

  • 1、与字符串一样，元组的元素不能修改。
  • 2、元组也可以被索引和切片，方法一样。
  • 3、注意构造包含0或1个元素的元组的特殊语法规则。
  • 4、元组也可以使用+操作符进行拼接。

 

三。set集合

集合（set）是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>> a = set('abracadabra')

>>> b = set('alacazam')
>>> print(a)
{'d', 'r', 'a', 'c', 'b'}
>>> print(b)
{'m', 'l', 'a', 'c', 'z'}
>>> print(a - b) //最好的记忆办法就是想成具体的减法运算，在a中减去b中有的剩下的元素
{'d', 'b', 'r'}
>>> print(a | b)
{'z', 'r', 'm', 'l', 'd', 'a', 'c', 'b'}      #取并
>>> print(a & b)        #取与，两个都有的元素
{'a', 'c'}
>>> print(a ^ b)             # a和b中不同时存在的元素
{'z', 'r', 'm', 'l', 'd', 'b'}
>>> 

四。字典

Dictionary（字典）



字典（dictionary）是Python中另一个非常有用的内置数据类型。




列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。（可以通过‘key’或者下标来访问具体建对应的值）




字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。




键(key)必须使用不可变类型。




在同一个字典中，键(key)必须是唯一的。




#!/usr/bin/python3 dict = {}


 dict['one'] = "1 - 菜鸟教程"


 dict[2] = "2 - 菜鸟工具"


tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} print (dict['one']) # 输出键为 'one' 的值


 print (dict[2]) # 输出键为 2 的值


 print (tinydict) # 输出完整的字典


print (tinydict.keys()) # 输出所有键


print (tinydict.values()) # 输出所有值




以上实例输出结果：


1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])
====================================


注意：


    

  • 1、字典是一种映射类型，它的元素是键值对。
    • 

  • 2、字典的关键字必须为不可变类型，且不能重复。
    • 

  • 3、创建空字典使用 { }。
    • 



 


Python数据类型转换


有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。


以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。





函数描述





int(x [,base])




将x转换为一个整数








long(x [,base] )




将x转换为一个长整数








float(x)




将x转换到一个浮点数








complex(real [,imag])




创建一个复数








str(x)




将对象 x 转换为字符串








repr(x)




将对象 x 转换为表达式字符串








eval(str)




用来计算在字符串中的有效Python表达式,并返回一个对象








tuple(s)




将序列 s 转换为一个元组








list(s)




将序列 s 转换为一个列表








set(s)




转换为可变集合








dict(d)




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








frozenset(s)




转换为不可变集合








chr(x)




将一个整数转换为一个字符








unichr(x)




将一个整数转换为Unicode字符








ord(x)




将一个字符转换为它的整数值








hex(x)




将一个整数转换为一个十六进制字符串








oct(x)




将一个整数转换为一个八进制字符串




















拓展：http://www.runoob.com/python3/python3-data-type.html




笔记列表


 






    

  1. 

    

    

       荆棘乱
    

      llc***n@gmail.com
    

    

    

    

    元组（小拓展）
    

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

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

    示例（命令行下）：
    

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

    荆棘乱

    

       荆棘乱
    

      llc***n@gmail.com
    

    
6个月前 (05-05)
    

    

    2. 

  2. 

    

    

       我去咬你啦
    

      815***114@qq.com
    

    

    

    

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

    我去咬你啦

    

       我去咬你啦
    

      815***114@qq.com
    

    
4个月前 (06-28)
    

    

    3. 

  3. 

    

    

       愤怒的胸毛毛
    

      zha***aijun2013@foxmail.com
    

    

    

    

    在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]
    

    但是第二句话有中括号
    

    愤怒的胸毛毛

    

       愤怒的胸毛毛
    

      zha***aijun2013@foxmail.com
    

    
4个月前 (07-02)
    

    

    4. 

  4. 

    

    

       hellowqp
    

      wqp***a@foxmail.com
    

    

    

    

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

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

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

    hellowqp

    

       hellowqp
    

      wqp***a@foxmail.com
    

    
3个月前 (07-08)
    

    

    5. 

  5. 

    

    

       燕春
    

      zqs***306010@qq.com
    

       参考地址
    

    

    

    

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

    燕春

    

       燕春
    

      zqs***306010@qq.com
    

       参考地址
    

    
1个月前 (09-15)
    

    

    6. 












	
posted on 
2017-10-22 22:16 
尴尬而不失礼貌的微笑 
阅读(278) 
评论(0) 
编辑 
收藏 
举报












    
    

    
    

    

        

    

        

            
                
                
            
        

    

        

            
                
            
        

    

    

    











	
		

			

			
                
                    

			

                    

	





	Powered by: 博客园
	Copyright © 2024 尴尬而不失礼貌的微笑

Powered by .NET 9.0 on Kubernetes