python学习之-内置数据结构_python3 span class 值-优快云博客

本文详细介绍了 Python 中的主要数据类型，包括数值型、序列对象、键值对等，并深入探讨了每种类型的特性和使用方法。文章还提供了大量实用示例，帮助读者更好地理解和运用 Python 的各种数据结构。

转自：http://www.178linux.com/87482

数值型

数值型
- int、float、complex、bool都是类(class),1、5.0、1+2j都是对象即实例
- int：在python3版本中表示长整型，没有大小限制，受限制于内存区域大小
- float:浮点数由整数部分和小数部分组成，支持十进制和科学计数法表示，在python中只有双精度浮点数
- complex：复数由实数和虚数部分组成，实数和虚数都是浮点数，例：3+4.2j
- bool：int的子类，基友两个实例True和False，分别代表1和0，可以直接和整数计算
类型转换
- int(x) #返回一个整数
- float(x) #返回一个浮点数
- complex(x)/comples(x,y) #返回一个复数
- bool(x) #返回布尔值，对应关系可查看真值表

数字的处理函数

python中管与数学处理的模块math需要单独导入(import math)，math.floor表示舍去小数部分的值取整，math.ceil表示只要小数位不是零则一律进1
int() #将括号内的浮点数小数点后的数值舍掉，只取整数部分
round() #这个函数去正式遵循四舍六入，当小数点后为5时，取离得最近的偶数值

可以测试下如下代码:

- print(math.ceil(2.1))

- print(math.floor(2.9))

- round(2.5)

- round(3.5)

- round(3.4)

- round(3.6)

- min() #取括号内数字的最小值

- max() #取括号内数字的最打值

- pow(x,y) #取x的y次方

- math.sqrt(9) #取就得0.5次方，也就是√-3

- math.pi #取π的值3.141592653589793

- math.e #取自然常数的值2.718281828459045

转换进制
- bin() #转换为二进制字符串
- oct() #转换位八进制字符串
- hex() #转换为十六进制字符串

类型判断
- type(object),返回类型，而不是字符串例：type(a)、type(‘b’)、type(123) type(1+True+3.0)返回的类型是浮点型，这是应为因为在数学计算中包含一个隐式转换，由精度低的数项精度高的数转换
- isinstance(obj,class_or_tuple),判断参数是不是后面其中一个的类型，返回布尔值例：isinstance(6,str) isinstance(6,(str,bool,int,float))

列表(list)

列表的特性
- 一个队列，排列整齐的队伍
- 列表里的个体称为元素(item)，有若干元素组成
- 元素可以式任意的数字、字符串、对象、列表等
- 列表内元素有顺序，可以使用索引
- 属于线性数据结构
- 使用[]表示，[]空的中括号表示空列表
- 列表是可以变化的,可以增、删、改、查和追加
列表list、链表(linklist)、队列(queue)、栈(stack)的差异
- 列表是有序地，一个接一个排列的集合，每一个元素占据一个单位，就像书本一样，一页内容对应一个页码，可以通过索引来查找
- 链表是有连接的，一个连一个的，好比手拉手，通过前一个元素可以找到下一个元素
- 队列可以是列表，也可以是链表，他可以项放行一样先进先出，也可以像解散一样后进先出
- 栈是以类似重叠的方式排列，就像摞盘子一样是典型的后进先出队列
列表list定义、初始化
- list() -> new empty list
- list(iterable) -> new list initialized from iterable’s items(从可迭代的元素初始化列表)
- 列表不能一开始就定义大小这是Python中的列表特性，它是可变化的
- 列表的元素也可以是函数的结果

列表索引访问

索引(index),也叫下标
正索引：从左到右，从0开始，是列表中每一个元素的编号
负索引：从右到左，从-1开始
正负索引不能超超界，超界后报错IndexError
默认认为列表是从左往右排列的，左边头部右边尾部，左边下界右边上界
列表可以通过索引来访问，格式为listname[index],index就是索引，是指某个元素在列表中的位置，默认从0开始

In [4]: lst

Out[4]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [5]:

In [5]: lst[6]

Out[5]: 6

In [6]:

列表查询
- index(valiue,[start,[stop]]) 1.通过值value，从指定区间查找列表的元素是否匹配 2.匹配第一个值就返回索引 3.匹配不到，显示valueError
- count(value) 返回列表中匹配到的值得次数
- 时间复杂度 1.index和count的方法复杂度是O(n)，O(1)这个是表示效率最高，一步操作；count的时间复杂度是O(n)表示所有元素查看一遍或者叫遍历，有n个元素就做n次操作 2.随着数据规模的增大，效率会越来越低
- 函数len() 查询项目中元素的个数，是公共的内建函数，可以查询类似集合的元素数量
查询帮助
- 查看帮助文档
- 查看官方文档
- 在ipython中通过help(keyword)
  - keyword可以是函数、类、对象、变量、方法名

列表元素修改当操作修改列表完成时若返回none值则没有新列表生成，是为就地修改

索引访问修改 list[index]=value,索引不能超界，否则就提示异常 -列表增加，插入元素

1. append(object) #尾部追加，不会生成新的列表，时间复杂度O(1)

2. insert(index,object) #在指定索引处插入一个值，索引开始到最后的元素整体后移一个单位，索引超下界会在头部追加，超上界尾部追加。由于操作会硬气内存结构的变化，所以一般不使用

3. extend（iteratable） #列表扩展：将可迭代对象的元素追加进来，就地修改

4. list1+list2 #连接操作，将两个列表连接起来，产生新表，原列表不变

5. list*num #重复操作，将本列表元素重复n次，返回新的列表

列表删除元素

1. remove(value) #从左往右查找第一个匹配的值并移除，就地修改

2. pop([index]) #不指定索引，从列表哦尾部弹出一个元素，或者制定索引，从指定索引出弹出元素

3. clear() #清楚对象列表中的所有元素，剩下一个空列表

列表其他操作

1.reversed() #将列表中元素颠倒顺序，就地修改

2.sort(key=None,reverse=False) #对列表惊醒排序，就地修改，默认升序；reverse=True,就是反转并按降序排列；key可以制定一个函数，指定key如何排序

3. in 查看一个元素在不在一个列表中；而for x in [1,2,3,4]表示从列表中取出元素附给x

列表复制
copy() #shadown cpoy(影子复制),也叫浅拷贝，遇到引用类型，只是复制了一个引用，如果引用的对象被修改，则两个列表所引用的元素都会改变，
深拷贝，copy模块提供深拷贝，深copy会在内存中新建一个列表，并赋值

随机数

random模块 1.random.randint(a,b) #返回[a,b]之间的整数 2.random.choice(seq) #从非空序列中随机挑选一个元素 3.randrange([start,]stop[,step]) #从指定按制定奇数递增的集合中获取一个随机数，默认奇数为1 4.random.shuffle(list) #就地打乱列表元素

练习

1.求100内的素数

lst=[2]

for i in range(3,100,2):

for n in lst:

if i%n ==0:

break

else:

#print(i)

lst.append(i) #将计算出的素数追加到素数列表中

print(lst)

import math

pn=[]

for x in range(3,1000,2):

for i in pn:

if x%i==0:

sign=True

break

if i>=math.ceil(x**0.5):

sign=False

break

if not sign: #只有是真值的时候，才会执行及里边的语句块，当flag为False，not flag是True,程序才会进去if内部语句块，否则就继续下面的语句

#print(x)

pn.append(x)

print(pn)

2.计算杨辉三角的前六行

triangle=[[1],[1,1]]

for i in range(2,6):

p = triangle[i-1]

cur=[1]

for j in range(0,i-1):

cur.append(p[j]+p[j+1])

cur.append(1)

triangle.append(cur)

print(triangle)

triangle=[]

for i in range(6):

if i==0:

lr=[1]

triangle.append(lr)

else:

p=triangle[i-1]

cur=[1]

for j in range(0,i-1):

cur.append(p[j]+p[j+1])

cur.append(1)

triangle.append(cur)

print(triangle)

triangle=[]

for i in range(6):

if i==0:

lr=[1]

triangle.append(lr)

else:

p=[0]

p.extend(triangle[i-1])

p.append(0)

cur=[]

for j in range(0,i+1):

cur.append(p[j]+p[j+1])

triangle.append(cur)

print(triangle)

triangle=[]

for i in range(6):

if i==0:

lr=[1]

triangle.append(lr)

elif i==1:

lr=[1,1]

triangle.append(lr)

else:

p=triangle[i-1]

cur=[1]

x=1

while x<=(i-1):

cur.append(p[x-1]+p[x])

x+=1

cur.append(1)

triangle.append(cur)

print(triangle)

方法二

ol=[]

nl=[1]

print(nl)

for i in range(1,6):

ol=nl.copy()

ol.append(0)

nl.clear()

offset=0

while offset<=i:

nl.append(ol[offset-1]+ol[offset])

offset+=1

print(nl)

元组(tuple)

元组是一个有序的元素组成的集合，使用()表示，元组是不可变对象，包括元祖的的长度和元素本身。如果元祖中的元素是一个引用对象，当引用对象本身发生变化是，元组中的元素才会发生变化。

定义
- tuplename=tuple() #定义一个空元组，括号里可以是可迭代对象、数字、字符串、列表等
- tuplename=tuple(2,) #当定义一个元素的元组时，要在元素后加个逗号，否则会提示括号所在的类不是一个可迭代对象
- tuple和list一样，可以使用‘+’连接两个不同的元组，创建一个新的元组打印出来，也可以通过‘*’创建一个被乘的元组重复几次的新元组打印出来。
- 元祖也支持索引访问，包括正负索引，其访问的方式和列表一样，但是索引不能超界，否则引发异常
- tuplename.index(9) #在tuplename这个元组中查看9的索引，会返回从左到右最近的匹配到的9的索引，匹配不到就返会valueerror。
- tuplename.count(9) #在tuplename这个猿族中查询9这个值在元组中出现了几次
- len(tuplename) #查询元祖的长度或者说是元组中元素的个数
- 元组类似于只读权限的文件，这可以读取，不能增改删，只能删除整个元组

命名元组namedtuple

namedtuple使用时需要执行命令“from collections import namedtuple”

namedtuple(typename,field_names（可以是空格或者逗号分隔的字段的字符串，也可以是字段的列表）,verbose=FaLse,rename=False) #命名元组，返回元组的子类，并定义字段例： ` In [2]: from collections import namedtuple

In [3]: Point=namedtuple('_Point',['x','y'])

In [4]: p=Point(11,22)

In [5]: p.x

Out[5]: 11

In [6]: p.y

Out[6]: 22

```

练习
- 以此接收用户输入的3个数，排序后打印
  1. 转换int后，判断大小排序
  2. 使用max函数
  3. 使用列表的sort方法
  4. 冒泡法

字符串

字符串是有序的字符集合或者称字符序列，支持使用索引访问，是一个可迭代的对象

字符串join连接 python种特殊字符需要转义后使用

例：

In [15]: lst

Out[15]: ['1', '2', '3']

In [16]: print('/'.join(lst))

1/2/3

In [17]: print('\\'.join(lst))

1\2\3

In [18]: print('"'.join(lst))

1"2"3

- 连接符和列表的用法一样，在这里是将两个字符串连接到一起返回一个新字符串

字符串分割 1.split系：将字符分割成若干字符串，并返回列表。

格式

- (string's name).split(sep=None,maxsplit=-1)

分割时时从左向右sep制定分割字符串，默认时空白字符串作为分隔符；maxsplit制定分割次数，-1表示便利整个字符串。

- (string's name).rsplit(sep=None,maxsplit=-1)

从右向左

- (string's name).splitlines([keepends])

按照行来切分字符串，keepends指的是是否保留行分隔符（\n、\r\n、\r等）

2.partittion系：将字符串按照分隔符分成两段，放回这两段和分割符的元组

- partition(sep（必须指定）)

从左到右，遇到分隔符就把字符串分成两部分，返回头(head)、分隔符、尾（tail）三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组

- rpartition(sep)

从右到左，功能同上

字符串大小写
- upper() 全大写
- lower() 全小写
- swapcase() 交互大小写，就是大写变小写，小写变大写。
字符串排版
- title 标题的每个单词首字母大写
- capitalize 第一个单词首字母大写
- center(width[,fillchar]) 打印字符串时居中打印，用多少个字符的宽度如果字符串不够用某个字符填充，默认字符是空格
- zfill(width) 右对齐打印，左边字符不够的用0填充
- ljust/rjust(width[,fillchar]) 左/右对齐打印