python学习笔记--内置数据结构

1、列表--是一个序列,用于顺序的存储数据

列表的定义与初始化

In [374]: lst = list()

In [375]: lst
Out[375]: []

In [376]: lst = []

In [377]: lst = [1,2,3]

In [378]: lst
Out[378]: [1, 2, 3]

In [379]: lst = list(range(1,10))

In [380]: lst
Out[380]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

访问列表元素

In [380]: lst
Out[380]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [381]: 

In [381]: 

In [381]: lst[0]
Out[381]: 1

In [382]: lst[-1]
Out[382]: 9

In [383]: lst.index(5)
Out[383]: 4

In [384]: 

In [384]: lst = [1,2,3,2,4,3,5]

In [385]: lst.index(2)    # index 方法返回查找到的第一个索引
Out[385]: 1

In [386]: lst.index(2,2)
Out[386]: 3

In [387]: lst.index(2,2,5)
Out[387]: 3

In [388]: lst.index(2,-4,-1)
Out[388]: 3

In [389]: lst.count(2)
Out[389]: 2

In [390]: lst.count(3)
Out[390]: 2
  • 通过索引访问元素
  • index方法根据值返回第一个索引
  • count方法返回元素在列表里的个数

列表元素的修改

In [391]: lst
Out[391]: [1, 2, 3, 2, 4, 3, 5]

In [392]: lst[2]
Out[392]: 3

In [393]: lst[2] = 5

In [394]: lst
Out[394]: [1, 2, 5, 2, 4, 3, 5]

In [395]: lst[2] 
Out[395]: 5

列表元素的增加

In [396]: lst
Out[396]: [1, 2, 5, 2, 4, 3, 5]

In [397]: lst.append(19)

In [398]: lst
Out[398]: [1, 2, 5, 2, 4, 3, 5, 19]

In [399]: lst.insert(0,20)

In [400]: lst
Out[400]: [20, 1, 2, 5, 2, 4, 3, 5, 19]

In [401]: lst.insert(-1,‘b‘)

In [402]: lst
Out[402]: [20, 1, 2, 5, 2, 4, 3, 5, ‘b‘, 19]

In [403]: lst.insert(100,‘a‘)

In [404]: lst
Out[404]: [20, 1, 2, 5, 2, 4, 3, 5, ‘b‘, 19, ‘a‘]

In [405]: lst.insert(-100,‘a‘)

In [406]: lst
Out[406]: [‘a‘, 20, 1, 2, 5, 2, 4, 3, 5, ‘b‘, 19, ‘a‘]

In [407]: 

#insert 当索引超出范围时,索引是负数 会在第0个元素前插入,索引是正数 会在最后一个元素后插入

In [407]: lst.extend([1,2,3])

In [408]: lst
Out[408]: [‘a‘, 20, 1, 2, 5, 2, 4, 3, 5, ‘b‘, 19, ‘a‘, 1, 2, 3]

#append操作单个元素,extend操作可迭代对象

列表元素的删除

In [410]: lst
Out[410]: [1, 2, 3, 2, 4, 3, 5, 3, 4]

In [411]: lst.remove(1)

In [412]: lst
Out[412]: [2, 3, 2, 4, 3, 5, 3, 4]

In [413]: lst.pop()
Out[413]: 4

In [414]: lst
Out[414]: [2, 3, 2, 4, 3, 5, 3]

In [415]: lst.pop(4)
Out[415]: 3

In [416]: lst
Out[416]: [2, 3, 2, 4, 5, 3]

In [417]: lst.clear()

In [418]: lst
Out[418]: []

其他操作

In [419]: lst = list(range(4))

In [420]: lst
Out[420]: [0, 1, 2, 3]

In [421]: len(lst)
Out[421]: 4

In [422]: 

In [422]: lst
Out[422]: [0, 1, 2, 3]

In [423]: lst.reverse()

In [424]: lst
Out[424]: [3, 2, 1, 0]

In [425]: 

In [425]: lst.sort()

In [426]: lst
Out[426]: [0, 1, 2, 3]

In [427]: lst.sort(reverse=True)

In [428]: lst
Out[428]: [3, 2, 1, 0]

In [429]: 

In [429]: lst
Out[429]: [3, 2, 1, 0]

In [430]: lst2 = lst

In [431]: lst2
Out[431]: [3, 2, 1, 0]

In [432]: lst2[1] = 5 

In [433]: lst2
Out[433]: [3, 5, 1, 0]

In [434]: lst
Out[434]: [3, 5, 1, 0]

In [435]: 

In [435]: lst2 = lst.copy()

In [436]: lst2
Out[436]: [3, 5, 1, 0]

In [437]: lst
Out[437]: [3, 5, 1, 0]

In [438]: lst2[1] = 7

In [439]: lst2
Out[439]: [3, 7, 1, 0]

In [440]: lst
Out[440]: [3, 5, 1, 0]

2、元组

定义及初始化

In [441]: t = tuple()

In [442]: t 
Out[442]: ()

In [443]: t = ()

In [444]: t 
Out[444]: ()

In [445]: t = (1,2,3)

In [446]: t
Out[446]: (1, 2, 3)

In [447]: t = tuple(range(3))

In [448]: t
Out[448]: (0, 1, 2)

元组是不可变的

查询

In [449]: t 
Out[449]: (0, 1, 2)

In [450]: t[0]
Out[450]: 0

In [451]: t[-1]
Out[451]: 2

In [452]: t.index(2)
Out[452]: 2

In [453]: t.count(2)
Out[453]: 1

命名元组

In [454]: from collections import namedtuple

In [455]: User1 = namedtuple(‘A‘,[‘name‘,‘age‘])

In [456]: me = User(‘martin‘,18)

In [457]: me
Out[457]: A(name=‘martin‘, age=18)

In [458]: me.age
Out[458]: 18

In [459]: me.name
Out[459]: ‘martin‘

In [460]: me[0]
Out[460]: ‘martin‘

In [461]: me[1]
Out[461]: 18
时间: 2024-10-07 16:49:23

python学习笔记--内置数据结构的相关文章

python学习笔记--内置数据结构2

1.字符串--是不可变的 定义及初始化 In [577]: s = 'hello wolrd' In [578]: s Out[578]: 'hello wolrd' In [579]: s = "hello python" In [580]: s Out[580]: 'hello python' In [581]: s = '''hello''' In [582]: s Out[582]: 'hello' In [583]: s = """hello&q

Python 学习笔记 -- 内嵌函数、闭包、匿名函数、高阶函数map、高阶函数filter、高阶函数reduce

1 #------------------------------内嵌函数------------------------------ 2 #内嵌函数就是在函数内部定义函数 3 #实例一 4 print("#------------------------------内嵌函数------------------------------") 5 def funOutOne(): 6 x = 5 7 def funIn(): 8 x = 3 9 print("My funOutO

python学习笔记11-python内置函数

python学习笔记11-python内置函数 一.查看python的函数介绍: https://docs.python.org/2/library/ 二.python内置函数 1.abs获取绝对值: 通过python官网查看abs abs(x) Return the absolute value of a number. The argument may be a plain or long integer or a floating point number. If the argument

python课程第二周 内置数据结构——列表和元组

5种内置数据结构:列表.元组.字典.集合.字符串.列表.字典.字符串三种被称为线性结构. 针对线性结构的操作有:切片.封包和解包.成员运算符.迭代. 针对数据结构的操作有解析式:解析式分为列表解析.生成器解析.集合解析和字典解析. 后面三种是Python3.x特有的. 基本框架如下: 一.列表:Python中最具灵活性的有序集合对象类型 列表可包含任何种类的对象:数字.字符串.字典.集合甚至其他列表,这个特性称为异构.还具有可变长度和任意嵌套的特性,属于可变长度序列. (1)列表的初始化,有两种

Python内置数据结构——列表list,元组tuple

内置数据结构分类: 数值型 int , float , complex , bool 序列对象 字符串 str 列表 list tuple(元组) 键值对 集合 set 字典 dict 数字型 int ,float , complex , bool都是class, 1,5.0 , 2+3j都是对象的实例 int : python3的int就是长整型,没有大小限制,受限于内存大小 float:有整数部分和小数部分组成,支持十进制和科学计数法表示,只有双精度型 complex:有实数和虚部组成,实部

Python内置数据结构

内置数据结构 可变 list 列表 byterray dict 字典 set 集合 不可变 tuple 元组 bytes 常量(int,str,bool 等) list 列表 (推荐使用索引)列表相当于一个排列整齐的队列,可以理解为在内存中是一片排列整齐的连续的空间,它是可索引,可变的,有序的,线性结构,可迭代.优点:通过索引(index)查找.替换元素 效率高 时间复杂度O(1).尾部追加(append)与 尾部移除(pop)元素快 效率高 时间复杂度O(1).缺点:从中间增加或移除元素会使列

Python内置数据结构操作VS sqlite3操作

1.摘要 在同一数据库中查询某值,内置数据结构的查询速度快还是数据库sqlite3的查询速度快?针对这一问题,通过构建一个包含2500个随机数的列表,并将其插入sqlite3数据库中,利用timeit模块,分别对内置数据结构list和sqlite3查询某一值在不在数据组中进行对比. 2.代码 >>> import numpy as np >>> import sqlite3 >>> test=np.random.randn(2500) >>

OpenCV之Python学习笔记

OpenCV之Python学习笔记 直都在用Python+OpenCV做一些算法的原型.本来想留下发布一些文章的,可是整理一下就有点无奈了,都是写零散不成系统的小片段.现在看 到一本国外的新书<OpenCV Computer Vision with Python>,于是就看一遍,顺便把自己掌握的东西整合一下,写成学习笔记了.更需要的朋友参考. 阅读须知: 本文不是纯粹的译文,只是比较贴近原文的笔记:         请设法购买到出版社出版的书,支持正版. 从书名就能看出来本书是介绍在Pytho

Python学习笔记--未经排版

Python 学习笔记 Python中如何做到Print() 不换行 答:Print("输出内容",end='不换行的分隔内容'),其中end=后面为2个单引号 注:在Python 2.x中,Print "输出内容", 即在输出内容后加一逗号 Python中 is 和 == 的区别 答:Python中的对象包含三要素:id.type.value 其中id用来唯一标识一个对象,type标识对象的类型,value是对象的值 is判断的是a对象是否就是b对象,是通过id来