精华内容
下载资源
问答
  • python内置类型

    2020-07-11 17:45:17
    python内置类型主要有一下几种 int 整数,也就是不带小数点的数字,例如3 999 -3 等等 float 浮点数, 也就是带有小数点的数字, 例如 3.14 bool 布尔值,只有两个True和False str 字符串, 使用引号引起来...

    python内置类型主要有以下几种

    1. int

    2. float

    3. bool
    4. str
    5. list
    6. tupe
    7. dict
    8. set
    9. bytes

    int

    整数,也就是不带小数点的数字,例如3  999   -3  等等

    float

    浮点数, 也就是带有小数点的数字, 例如 3.14

    bool

    布尔值,只有两个True和False

    str

    字符串, 使用引号引起来的一串字符, 可以使用索引与切片访问其中的字符与子字符串

    list

    列表, 使用中括号括起来的一组元素,元素可以是任意类型,同样支持索引与切片

    tuple

    元组,使用小括号括起来的一组元素,元素可以是任意类型,同样支持索引与分片, 与列表不同的是,元组对象是不可修改的,即不可以向元组中添加删除元素,也不可以给元组里的元素重新赋值

    dict

    字典, 相当于数据结构中的哈希表,散列表, 每个元素都是键值对的格式,键和值使用冒号隔开, 值可以是任意类型, 字典中键是唯一的(即不能有相同的键), 键不可以是可修改的类型, 例如列表,字典和集合

    set

    集合, 使用大括号括起来的一组没有重复值的元素

    bytes

    字节串, 在字符串前面加上b, 就是字节串了, 以字节为单位访问

     

    展开全文
  • 主要介绍了容易被忽略的Python内置类型,帮助大家更好的理解和学习python,感兴趣的朋友可以了解下
  • 主要介绍了Python内置类型性能分析过程实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python 内置类型简述

    千次阅读 2017-04-26 10:31:12
    Python 内置类型这里学习内容...目录Python 内置类型 目录 for lelp 核心数据类型 数字 序列的操作 索引 不可变性 列表 特定的操作方法 边界检查 嵌套 列表解析 字典 创建方法常量 创建空字典然后再逐个填充 索引 嵌套

    Python 内置类型简述

    这里学习内容来自于 《Python学习手册》https://learnpythonthehardway.org/book/

    目前只更新到 字典 ,会不断补充后续内容。

    for lelp

    之所以把这一项放在开头,是提醒自己多查看python手册
    ,或是”help(struc.method)”

    核心数据类型

    内置对象类型

    • 数字:1234, 3.1415, 3+4j, Decimal, Fraction
    • 字符串:'spam', "guido's", b'a\xolc'
    • 列表:[1,[2,'three'],4]
    • 字典:{'food':'spam','taste':'yum'}
    • 元组:(1,'spam',4,'U')
    • 文件:myfile=open('eggs','r')
    • 集合:set('abc'),{'a','b','c'}
    • 其它类型:None, bool
    • 编程单元类型:函数、模块、类

    数字

    类似于其他编程语言,Python也包括常见的:整数浮点数其它(有虚部的复数、固定精度的十进制数、有分子和分母的有理分数)集合

    除了表达式,还有一些常用的 数学模块,里面包括高级的数学工具、如函数。random 可生成随机数也可作随机选择器

    >>>import math
    >>>math.pi
    >>>nath.sqrt(9)
    
    >>>import random
    >>>random.random()
    >>>random.choice([1,2,3,4])

    序列

    含义

    一个“序列”是一个对位置进行排序的对象的集合。包括 字符串、列表、元组

    操作

    它们共同拥有一般的序列操作,包括 索引、分片、合并,但是也有其各自特定的操作方法。

    索引

    以”China”为例:

    s = "China"
    len(s)      

    索引是按照 偏移量 进行的,自然是从0开始的,比如:

    s[0]
    'C'

    分片

    s[1:4]
    'hin'   
    >>> s[:]
    'China'

    也可以通过 负偏移量 进行索引,例如-1则是指最后一项,比如:

    >>> s[-1]
    'a'
    >>> s[:-1]
    'Chin'

    合并

    “+” 用以合并

    >>> s + ", I love you!"
    'China, I love you!'

    不可变性

    表示一旦创建后,不能随意更改。比如,不能通过对其某一位置赋值而改变该字符串,但是可以以原来的变量名创建一个新的字符串,因为会覆盖掉原来的对象。

    不可变:数字、字符串、元组
    可变: 列表、字典

    列表

    特定的操作,方法

    methods

    边界检查

    若是给超出列表边界外的元素赋值,会出错。

    嵌套

    列表可支持 任意嵌套。一个直接应用就是实现 矩阵,或是 多维数组

    列表解析

    列表解析源自集合的概念。列表解析是写在 方括号 中的,且由使用了同一个变量名的表达式和 循环结构 组成。它是一种通过 对序列中的每一项运行一个表达式来创建一个新列表的方法,每次一个,从左至右

    解析可以用来创建 列表、集合和字典

    字典

    不是序列,而是一种 映射(Mapping),映射,是通过 而不是相对位置来存储的。没有从左至右的顺序,只是将 映射到值。具有 可变性

    创建方法

    写在 大括号{ } 内,包含一系列的 “键:值” 对。

    常量
    >>> d = {'food':'pizza', 'quantity':'2', 'flavor':'bacon'}
    创建空字典,然后再逐个填充
    >>> d = {}  
    >>> d['food'] = 'pizza'  
    >>> d['quantity'] = '2'  
    >>> d['flavor'] = 'bacon'  

    索引

    索引 操作,与序列的索引语法相同,只是语句中方括号内是“键”,而不再是相对位置。字典,侧重的是内容上的 关联性

    字典也可以用来进行搜索,通过键索引一个字典是python中编写搜索的最快方法。

    嵌套

    例如:

    >>> info = {'name':{'first': 'Lin', 'last': 'Liu'},  
                'age': 23,  
                'interests':['photography', 'reading']}  
    >>> info['name']['first']  
    'Liu'  
    >>> info['interests'][-1]  
    'reading'  
    >>> info['interests'].append('travel')  
    >>> info  
    {'name':{'first': 'Lin', 'last': 'Liu'}, 'age': 23, 'interests':['photography', 'reading', 'travel']}   

    可以看出python数据类型的灵活性。

    for循环,键排序

    前面提到,字典不像序列一样,它并没有从左到右的顺序。但是有时又需要强调某种顺序,该怎么办?
    在较新版本的Python中,可以直接使用sorted()函数完成:
    sorted()

    元组

    元组是序列,但是类似字符串 具有 不可变性,不可以更改,不可以增长或缩短。
    写在 圆括号() 内,支持任意类型、任意嵌套以及常见的序列操作:

    >>> num = (1, 2, 3, 4)
    >>> len(num)              # length
    4
    >>> num + (5, 6)          # 合并
    (1, 2, 3, 4, 5, 6)
    >>> num[0]
    1

    元组还有 专用的调用方法

    >>> num.index(4)         # 返回4所在位置
    3
    >>> num.count(4)         # 返回4出现的次数
    1

    那么问题来了:
    既然它不能随意改变,都不灵活,我们为什么要用元组呢?
    正是因为它的不可变性,合适的情况下,劣势便是优势,所以说要辩证地看待问题

    展开全文
  • 本文讲述了Python内置类型。记录以供学习。具体如下: python内置类型 1、list:列表 (即动态数组,C++标准库的vector,但可含不同类型的元素于一个list中) 代码如下: a = ["I","you"...

    本文讲述了Python内置类型。记录以供学习。具体如下:

    python内置类型

    1、list:列表 (即动态数组,C++标准库的vector,但可含不同类型的元素于一个list中)
    代码如下:

    a = ["I","you","he","she"]      #元素可为任何类型。1

    下标:按下标读写,就当作数组处理
    以0开始,有负下标的使用
    0第一个元素,-1最后一个元素,
    -len第一个元 素,len-1最后一个元素
    取list的元素数量
    复制代码 代码如下:
    len(list) #list的长度。实际该方法是调用了此对象的len(self)方法。

    创建连续的list
    代码如下:

    L = range(1,5)      #即 L=[1,2,3,4],不含最后一个元素
    L = range(1, 10, 2) #即 L=[1, 3, 5, 7, 9]12

    list的方法
    代码如下:

    L.append(var)   #追加元素
    L.insert(index,var)
    L.pop(var)      #返回最后一个元素,并从list中删除之
    L.remove(var)   #删除第一次出现的该元素
    L.count(var)    #该元素在列表中出现的个数
    L.index(var)    #该元素的位置,无则抛异常
    L.extend(list)  #追加list,即合并list到L上
    L.sort()        #排序
    L.reverse()     #倒序123456789

    list 操作符:,+,*,关键字del
    代码如下:

    a[1:]       #片段操作符,用于子list的提取
    [1,2]+[3,4] #为[1,2,3,4]。同extend()
    [2]*4       #为[2,2,2,2]
    del L[1]    #删除指定下标的元素
    del L[1:3]  #删除指定下标范围的元素12345

    list的复制
    代码如下:

    L1 = L      #L1为L的别名,用C来说就是指针地址相同,对L1操作即对L操作。函数参数就是这样传递的
    L1 = L[:]   #L1为L的克隆,即另一个拷贝。12

    2、dictionary: 字典(即C++标准库的map)
    代码如下:

    dict = {'ob1′:'computer', 'ob2′:'mouse', 'ob3′:'printer'}1

    每一个元素是pair,包含key、value两部分。key是Integer或string类型,value 是任意类型。
    键是唯一的,字典只认最后一个赋的键值。

    dictionary的方法
    代码如下:

    D.get(key, 0)       #同dict[key],多了个没有则返回缺省值,0。[]没有则抛异常
    D.has_key(key)      #有该键返回TRUE,否则FALSE
    D.keys()            #返回字典键的列表
    D.values()
    D.items()
    D.update(dict2)     #增加合并字典
    D.popitem()         #得到一个pair,并从字典中删除它。已空则抛异常
    D.clear()           #清空字典,同del dict
    D.copy()            #拷贝字典
    D.cmp(dict1,dict2)  #比较字典,(优先级为元素个数、键大小、键值大小)
    #第一个大返回1,小返回-1,一样返回01234567891011

    dictionary的复制
    代码如下:

    dict1 = dict        #别名
    dict2=dict.copy()   #克隆,即另一个拷贝。12

    3、tuple:元组(即常量数组)
    代码如下:

    tuple = ('a', 'b', 'c', 'd', 'e')1

    可以用list的 [],:操作符提取元素。就是不能直接修改元素。
    4、string: 字符串(即不能修改的字符list)
    代码如下:

    str = "Hello My friend"1

    字符串是一个整 体。如果你想直接修改字符串的某一部分,是不可能的。但我们能够读出字符串的某一部分。
    子字符串的提取
    代码如下:

    str[:6]1

    字符串包含 判断操作符:in,not in
    代码如下:

    "He" in str
    "she" not in str12

    string模块,还提供了很多方法,如
    代码如下:

    S.find(substring, [start [,end]]) #可指范围查找子串,返回索引值,否则返回-1
    S.rfind(substring,[start [,end]]) #反向查找
    S.index(substring,[start [,end]]) #同find,只是找不到产生ValueError异常
    S.rindex(substring,[start [,end]])#同上反向查找
    S.count(substring,[start [,end]]) #返回找到子串的个数
    S.lowercase()
    S.capitalize()      #首字母大写
    S.lower()           #转小写
    S.upper()           #转大写
    S.swapcase()        #大小写互换
    S.split(str, ' ')   #将string转list,以空格切分
    S.join(list, ' ')   #将list转string,以空格连接123456789101112

    处理字符串的内置函数
    代码如下:

    len(str)                #串长度
    cmp("my friend", str)   #字符串比较。第一个大,返回1
    max('abcxyz')           #寻找字符串中最大的字符
    min('abcxyz')           #寻找字符串中最小的字符
    string的转换
    oat(str) #变成浮点数,float("1e-1″)  结果为0.1
    int(str)        #变成整型,  int("12″)  结果为12
    int(str,base)   #变成base进制整型数,int("11″,2) 结果为2
    long(str)       #变成长整型,
    long(str,base)  #变成base进制长整型,12345678910

    字符串的格式化(注意其转义字符,大多如C语言的,略)
    代码如下:

    str_format % (参数列表)  #参数列表是以tuple的形式定义的,即不可运行中改变
    >>>print ""%s's height is %dcm" % ("My brother", 180)
    #结果显示为 My brother's height is 180cm123

    list 和 tuple 的相互转化
    代码如下:

    tuple(ls)
    list(ls)12

    Python 去掉List中重复的元素
    代码如下:

    a = [3, 3, 5, 7, 7, 5, 4, 2]
    a = list(set(a)) # [2, 3, 4, 5, 7] 连排序都做好了12

    参考链接:http://www.jb51.net/article/56769.htm

    展开全文
  • Python内置类型性能分析Python内置类型性能分析timeit模块class timeit.Timer(stmt='pass', setup='pass', timer=)timeit.Timer.timeit(number=1000000)list的操作测试list内置操作的时间复杂度dict内置操作的时间...

    1.7. Python内置类型性能分析

    在这里插入图片描述

    Python内置类型性能分析

    timeit模块

    timeit模块可以用来测试一小段Python代码的执行速度。

    class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=)

    Timer是测量小段代码执行速度的类。

    stmt参数是要测试的代码语句(statment);

    setup参数是运行代码时需要的设置;

    timer参数是一个定时器函数,与平台有关。

    timeit.Timer.timeit(number=1000000)

    Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数,默认为1000000次。方法返回执行代码的平均耗时,一个float类型的秒数。

    list的操作测试

    def test1():
       l = []
       for i in range(1000):
          l = l + [i]
    def test2():
       l = []
       for i in range(1000):
          l.append(i)
    def test3():
       l = [i for i in range(1000)]
    def test4():
       l = list(range(1000))
    
    from timeit import Timer
    
    t1 = Timer("test1()", "from __main__ import test1")
    print("concat ",t1.timeit(number=1000), "seconds")
    t2 = Timer("test2()", "from __main__ import test2")
    print("append ",t2.timeit(number=1000), "seconds")
    t3 = Timer("test3()", "from __main__ import test3")
    print("comprehension ",t3.timeit(number=1000), "seconds")
    t4 = Timer("test4()", "from __main__ import test4")
    print("list range ",t4.timeit(number=1000), "seconds")
    
    # ('concat ', 1.7890608310699463, 'seconds')
    # ('append ', 0.13796091079711914, 'seconds')
    # ('comprehension ', 0.05671119689941406, 'seconds')
    # ('list range ', 0.014147043228149414, 'seconds')
    

    pop操作测试

    x = range(2000000)
    pop_zero = Timer("x.pop(0)","from __main__ import x")
    print("pop_zero ",pop_zero.timeit(number=1000), "seconds")
    x = range(2000000)
    pop_end = Timer("x.pop()","from __main__ import x")
    print("pop_end ",pop_end.timeit(number=1000), "seconds")
    
    # ('pop_zero ', 1.9101738929748535, 'seconds')
    # ('pop_end ', 0.00023603439331054688, 'seconds')
    

    测试pop操作:从结果可以看出,pop最后一个元素的效率远远高于pop第一个元素

    可以自行尝试下list的append(value)和insert(0,value),即一个后面插入和一个前面插入???

    list内置操作的时间复杂度

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sYT5LHwP-1580541147753)(../images/list%E6%93%8D%E4%BD%9C.png)]

    dict内置操作的时间复杂度

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q1ONJzE0-1580541147753)(../images/dict%E6%93%8D%E4%BD%9C.png)]

    展开全文
  • Python内置类型性能分析timeit模块timeit模块可以用来测试一小段Python代码的执行速度。class timeit.Timer(stmt='pass', setup='pass', timer=<timer function>)Timer是测量小段代码执行速度的类。...
  • 近段时间发现一个 Python 连接数据库的连接是线程不安全的,结果惹得我哪哪儿都怀疑变量的多线程是否安全的问题,今天终于找到了正确答案,那就是 Python 内置类型 dict,list ,tuple 是线程安全的。 请参考官方...
  • 文章目录算法与数据结构--基于pythonPython内置类型性能分析timeit模块计时器类timeit.Timer计时器类下的timeit.Timer.timeit方法举个例子list内置操作的时间复杂度dict内置操作的时间复杂度 算法与数据结构–基于...
  • 近段时间发现一个 Python 连接数据库的连接是线程不安全的,结果惹得我哪哪儿都怀疑变量的多线程是否安全的问题,今天终于找到了正确答案,那就是 Python 内置类型 dict,list ,tuple 是线程安全的。 请参考官方...
  • cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9} # 获取'BMW'对应的value print(cars.get('BMW')) # 8.5 print(cars.get('PORSCHE')) # None print(cars['PORSCHE']) # KeyError

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,449
精华内容 4,579
关键字:

python内置类型

python 订阅