python内置数据结构

python内置数据结构

sort(key=none,resverse=false)—>none

对列表元素进行排序，就地修改。默认升序

resvers为true，反转，降序

key为一个函数，指定key如何排序

ls.sort(key=functionaame)

Print(lst.sort(key=str,reverse=Ture)

In

[3,4]in[1,2,[3,4]]

for x in [1,2,3,4]

列表复制

copy()  –> list

Shadow copy 返回一个新的列表

影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用

深拷贝

copy模块提供了deepcopy

Import copy

Lst0 = [1,[2,3,5,],5]

Lst5 = copy.deepcopy(lst0)

Lst5[1][1] = 0

Lst5 == lst0

随机数

random模块

Randint(a,b)返回a b 之间的随机数

Choice（seq）从非空序列的元素中随机挑选一个元素，比如random.choice（range（10）），从09随机挑选一个整数

列表练习

求100以内的素数

#求100以内的素数

import math

lst = []

n = 100

for i in range(2,n):

    for j in lst:

        if not i%j:

            break

    else:

        print(i)

        lst.append(i)

元组tuple

一个有序的元素组成的集合

使用小括号（）表示

元组是不可变的对象

元组元素的访问

支持索引（下标）

正索引：从左到右，从0开始，为列表中的每一个元素编号

负索引：从右到左，从负一开始

正负索引不可以超界，引发indexerror

Index（value，[start,[stop]]）

通过value值，从指定区域查找列表内的元素是否匹配

匹配第一个就立即返回索引

匹配不到就抛出异常valueerror

Count(value)

返回列表中匹配value的次数

时间复杂度

Index和count方法都是O（n）

随着数据规模的增大，而效率下降

Len（tuple）

反回元素的个数

杨辉三角

1.

trangle = [[1],[1,1]]

n = 6

for i in range(2,n):

    newline = [1]

    pre = trangle[i-1]

    for j in range(i-1):

        val = pre[j] + pre[j+1]

        newline.append(val)

    newline.append(1)

    trangle.append(newline)

print(trangle)

2.

  n = 6

for i in range(n):

    newline = [1]

    if i == 0:

        print(newline)

        continue

    for j in range(i-1):

        val = pre[j] + pre[j+1]

        #print(val)

        newline.append(val)

        #print(newline)

    newline.append(1)

    print(newline)

    pre = newline

元组tuple

一个有序的元素组成的集合

使用小括号()表示

元祖是不可变的对象

定义：tuple() –>empty tuple

 Tuple(iterable) –>

元组元素的访问

支持索引

正索引：从左到右，从0开始，为列表中每一个元素编号

负索引：从右到左，从-1开始

正负索引不可以超界，否则引发indexerror

Tuple[index]  index就是索引，使用中括号访问

冒泡法

lst = [8,9,5,7,2,6,4,3,1,0]

lenth=len(lst)

for i in range(lenth):

    for j in range(lenth-i-1):

        if lst[j]>lst[j+1]:

            lst[j],lst[j+1]=lst[j+1],lst[j]

print(lst)

字符串

一个个字符串组成的有序的序列，是字符的集合

使用单引号，双引号，三引号住的字符串序列

字符串是不可变的对象

python3起，字符串就是Unicode类型

字符串元素访问—下标

sql = “select  *  from user where name=’tom’”

Sql[4]#字符串‘c’

Sql[4] = ‘o’

有序的字符集合。字符序列

For c in sql:

Print(c)

Print(type(c)) #什么类型

可迭代

Lst  = list（sql）

字符串join连接

“string”.join(iterable) -> str

将可迭代对象连接起来，使用string作为分隔符

可迭代对象本身元素都是字符串

返回一个新的字符串

lst = [‘1′,’2′,’3’]

print(“\””.join(lst))

print(” “.join(lst))

print(“\n”.join(lst))

字符串分割

分割字符串的方法分为2类

Split系

将字符串按照分隔符分成若干字符串，并返回列表

Partition系

将字符串按照分隔符分成2段，返回这两段和分隔符的元组

Rsplit（sep=none，maxsplit= -1）-> lsit of strings

从右到左

sep指定分割字符串，缺省的情况下空白字符串作为分割符

Maxsplit指定分割的次数，-1表示遍历整个字符串

字符串大小写

Upper（）全大写  lower（）全小写    swapcase（）交互大小写

Tile() -> str

标题的每个单词都大小写

capitalize（）->首个单词大写

Center（width[,fillchar]）->str

Width 打印宽度

Fillchar 填充的字符

字符串修改

replace（old，new[,count]）->str

字符串中找到匹配的替换为新的字符串，返回新字符串count表示替换几次，不指定默认全部

字符串查找*

find（sub[start[,end]]） —> int

在指定的区间[start,end],从左到右，查找字串sub。找到返回索引，没找到返回-1

Rfind（sub[start[end]]） —> int

在指定的区间[star,end],从右到左查找子串sub。找到返回索引，没找到返回-1

Index（sub[start[end]]）  –>int

在指定的区间[start,end],从左到右查找子串sub，找到返回索引没找到抛出异常ValueError

rIndex（sub[start[end]]）  –>int

在指定的区间[start,end],从左到右查找子串sub，找到返回索引没找到抛出异常

字符串判断

Endswith(suffix[start,end]])—–> bool

在指定的区间start,end 字符串是否以suffix结尾

Startswith（prefix[start,end]]）—>bool

在指定的区间tart，end   字符串是否以prefix开头