python的内置数据结构及基础算法

一.python内置结构

---

1.理论知识

（1）数值型

int(x)返回一个整数
float（x）返回一个浮点数
complex（x）返回一个负数
bool（x）返回一个布尔值

(2).数字的处理函数

round（），四舍六入五取偶
floor（）向下取整，ceil向上取整
// 整除向下取整
int() 取整数部分

（3）.进制函数，返回值是字符串

bin()
oct()
hex()

(4).类型判断

type(),返回的是类型，不是一个字符串
lsinstanc(a，(int,str,bytes)),返回的死一个布尔值

2.列表list

（1).基本概念：一个队列，一个排列整齐的队伍，列表内的个体称作为元素；由若干个元素组成列表；元素可以是任意对象（数字，字符串，对象，列表等）；列表内元素是由顺序，可以使用索引；线性的数据结构；使用[ ]表示

lst=list()
lst=[]
lst=list(range(5))

（2）.列表查询

• index（value,start）

通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个值就返回这个值得索引
匹配不到，会抛出异常value error

• count（value）

返回这个值在列表的出现的次数

• 时间时间复杂度

index和count方法都是大o(n)
随着列表数据规模的增大，而效率下降

（3）.列表元素修改

索引访问修改: list[2]=100
索引不要越界

（4).列表增加，插入元素

• append（obj）

1.返回的是none
2.返回是none就意味着没有生成新的列表，就地修改
3.时间复杂度是O(1)

• insert(index,value)

1.在索引制定的地方插入元素
2.返回none就意味着没有生成新的列表，就地修改
3.时间复杂度是O(1)

• extend

1.将可迭代对象的元素追加进来，返回none
2.就地修改

• ±>list

连接操作，将两个列表连接起来
产生新的列表

（5).列表删除元素

• remove（value）

1.从左向右查找第一个匹配的value的值，移除该元素，返回none

• pop（index）

如果不指定，就相当于直接在列表尾部弹出一个元素
指定索引,j就从索引进行操作

（6）列表其他操作

• reverse（）->none
  1.将列表元素反转，返回none
  2.就地修改
• sort
  1.sort（key=，reverse=False）->none
  2.revserse 为true，反转，降序
  3.key一个函数，指定key如何排序
• in
• x in [ ] 返回布尔值
  （6）.列表复制
• shadow copy

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

• 深拷贝
  import copy
  lst0=[1,[2,3,4],5]
  lst5=copy.deepcopy(lst0)

3.随机数

random模块

random.randint(a,b)返回[a,b]之间的整数
random.randrange(1,7,2),从指定范围，按照指定基数递增的集合中获取一个随机数
random.sample 从样本空间中（序列或者即合类型）中随机取出K个不同的元素，返回一个新的列表

4.元组

基础概念
1.一个有序的元素组成的集合
2.使用小括号（）表示
3.元组是不可变对象

定义：t=tuple()
t=()
t=tuple(range(1,7,2))
t=(1,)
t=(1,)*5

4.namedtuple
point=nametuple(’_point’,[‘x’,‘y’])#point为返回的类

p=point(11,12)  
from collections import namedtuple
student=namedtuple('xiaohuihui','name age')
tom=student('tom',20)
jerry=student('xiaohui',20)
jerry.name
'xiaohui'

4.字符串

字符串是对可变对象

• 1.字符串join链接

’string‘.join(interable)->str
将可迭代对象 ，一般是对列表进行操作，使用string作为分隔符
可迭代对象本身元素都是字符串
返回一个新的字符串

2.字符串分割*

• 分割字符串的方法分为两类
  1.split，将字符串分割成若干个字符串，并返回一个列表
  2.partition，将字符串按照分隔符分割成两段，返回这两段和分隔符的元组

split(方法)
s1="lm \ta super student"
s1.split()
['lm', 'a', 'super', 'student']
s1.split('s')
['lm \ta ', 'uper ', 'tudent']

partition(方法)
从左向右，遇到分隔符九八字符串分割成两部分，返回头，分隔符，尾三部分的三元组
s1='lm a super student'
s1.partition('s')
('lm a ', 's', 'uper student')

3.字符串大小写

upper() 全大写
lower（）全小写
swapcase（）交换大小写

4.字符串修改

repalce(方法)
s1='www.baidu.com'
s1.replace('w','p')
'ppp.baidu.com'

strip
1.strip(chars)从字符串两端去除指定的字符集chars中的所有字符
2.如果chars，没有指定，去除两端的空白字符

5.字符串查找

1.从左向右进行查找
s='l am very very very sorry'
s.index('very')
2.从右向左进行查找
s.rindex('very',10,15)10和15是字符串开始的位置和结束的位置

6.字符串格式化*

format函数格式字符串
1.“{}{}”.format(*ars,**kwarges)
args是可变位置参数，是一个元组
kwargs是可变关键字参数，是一个字典
换括号表示占位符
{}表示按照顺序匹配位置参数，{n}表示去位置参数索引为n的值
{}表示在关键字参数中搜索名字一致的
{{}}表示打印花括号
2.对齐
’{}*{}={2：<2}‘.format(3.2.2**3)
‘：<2’表示索引为2的元素向左对齐两位’

---

基础算法

1. 根据半径计算圆周的面积和周长
r=int(input('>>>>'))
S=3.14*(r**2)
C=2*r*3.14
print("周长",S)
print("面积",C).
2.输入两个数，比较大小后，从小到大升序打印
a=int(input('>>>'))
b=int(input('>>>'))
if a>=b:
    print(b,a)
else:
    print(a,b)
3.输入若干个整数，打印出最大值，如果为空则退出程序
max=0
while True:
    a=input('>>>')
    if a==' ':
         break
    else:
        b=int(a)
        if b>max:
            max=b
            print(max)  
        else:
            print(max)
4.打印一个边长为n的正方形
n=int(input('>>>'))
print('* '*n)
for i in range(n-2):
    print('* '+'  '*(n-2)+'*')
print('* '*n)
5.求1到5的阶乘和
sums=0
for i in range(1,6):
    J=1
    for j in range(1,i+1):
        J*=j
    sums+=J
print(sums)
6.  求10万以内所有素数
upper=100000
for i in range(3,upper,2):
    if i>=10 and i%5==0:continue#为了不让被
    for  j in range(3,int(i**0.5)+1,2):
        if i%j==0:  
            break
    else:
        print(i)
 
7.打印99乘法表
for i in range(1,10):
    new=''
    for j in range(1,i+1):
       new+='{}+{}={} '.format(j,i,i*j)
    print('{:1}'.format(new))
8.斐波那契数列
i=1
j=1
count=2
while True:
    c=i+j
    count+=1
    if count==101:
        break
    i,j=j,c
print(c)
8.杨辉三角
n=9
before=[1]
print(before)
before.insert(0,0)
before.append(0)
for i in range(1,n):
    
    new=[]
    for j in range(i+1):
            m=before[j]+before[j+1]
            new.append(m)
            
    print(new)
    new.insert(0,0)
    new.append(0)
    before=new
   9.冒泡法排序
   count=0
nums=[1,2,3,4,5,6,7,8,9]
length=len(nums)
for i in range (length-1):
    count+=1
    swap=0
    for j in range(length-1-i):
        if nums[j]>nums[j+1]:
            nums[j+1],nums[j]=nums[j],nums[j+1]
            swap+=1
    print(swap)
    if swap==0:
        break
print(nums)

感谢大家支持：

欢迎志同道合的朋友：成为小灰灰的朋友