python入门之内置数据结构入门

Posted 2020-10-08

分类（大部分操作为 int和字符串）

数值型

int整型
folat浮点型
complex复数（实虚数组成）
bool布尔值（为int的子类，仅有true和，false）

序列对象

     字符串str

     列表list

键值对

     集合set

     字典dict

数字的处理函数

round（）四舍六入五取偶
地板向下floor（），天花板向上ceil（）
int（）取整数部分，和//整除一样

取大小常用

min（[1,3,5]）
1
max（[1,3,5]）
5
pow（5,2）开平方
25

进制函数，返回是字符串

bin（）2进制
oct（）八进制
hex（）十进制
math.pi=π

类型判断

type 返回类型，不是字符串
isintance 返回布尔值
isintance（a（int,str））
返回值为 true

列表list

*列表是可变的
list的符号为 []
元素可以是任意对象（字符串，数字，对象，列表等）
是一个有序的整齐的队伍
用[ ]来表示，是线性的数据结构，列表内元素有顺序，可以使用索引
列表list定义，初始化
列表不能一开始就定义大小

列表索引访问

索引 也叫下表
有正负索引，不可超界，否则会异常indexerror
正索引从0开始，为列表中每一个元素编号，负索引从右到做从-1开始
列表为从左到右排列的，左边为头，右边为尾，左边为上，右边为下

列表通过索引访问

list[index]，index就是索引，使用括号中访问
如 lst=[2,567]
list[1]就会显示 lst[567]

列表查询

index（value，[ start,[stop]]）
index 通过值value，从指定区间查找匹配元素，匹配第一个元素就会返回索引，
匹配不到就会跳出valueerror
count（value）
返回列表中匹配value 的次数
时间复杂度
     index和count都是O(n)
     随着列表数据规模增大，效率下降
len（list）
返回列表内的个数

列表增加，插入元素 

append
     列表尾部追加，返回none
     就地修改
     时间复杂度为O(n)

insert

在指定索引位置插入元素
就地修改
时间复杂度O(1)
超越上界，尾部追加，超越下界，头部追加

列表增加，插入元素

 extend 
将可迭代对象元素追加进来
就地修改
+-
连接操作，将两个列表连接起来
产生新的列表，原列表不变
*重复操作，将本列表元素重复n次，返回新的列表

列表删除元素

remove 
从左到右查找第一个匹配的值，移除该元素
就地修改
效率低O(n)
pop
不指定索引，从尾部弹出
指定索引，从索引处弹出一个元素
取尾部效率快=O(1)
clear
清除列表所有元素，只剩一个空列表
jc垃圾回收

反转

reversed
将列表元素反转，并返回值
就地修改
sort(key=none,reverse=false)排序
对列表元素进行排序，就地修改，默认升序
reverse为true，反转，降序
key一个函数，指定key如何排序
     lst.sort(key=functionname)
可以使用key进行字符与字符串的排序

in          

可以用来测试该元素是否在列表内，并返回布尔值
  pass语句，占位语句！

以上操作应考虑效率问题，

列表的复制

shadow copy（影子拷贝)
浅拷贝，只是复制一个引用而已

深拷贝

lst=copy.deepcopy(lst0)
copy模块提供了deepcopy
会拷贝引用类型到拷贝目录下并和源列表不干扰

随机数（伪随机数）

random模块
randint（a,b）返回[a,b]之间 的整数
choice（seq），从非空序列的元素中随机挑选一个整数
randrange（[start，]stop[，step]）前闭后开模式；从指定基数递增的集合中获取一个随机数为1，基数的缺省值为1
random.shuffle(list)   没有返回，就地打乱列表元素

冒泡法

属于交换排序。两两比较，并互相交换位置，结果分为升序和降序排列
升序从左至右排列，编号从0开始到n-1
降序则和升序相反

字符串

一个有序的序列，是字符的集合。能使用引号，三双引号  ，是不可变对象  是unicode类型
字符串定义 初始化
赋值即定义
字符串元素访问，下标
支持索引访问，有序的字符集合，字符序列，可迭代

字符串分割

split（sep=none,maxsplit1）

     由左至右
     sep制定分割字符串，默认使用空白字符为分割符
     maxspilt 制定分割的次数，-1表示遍历整个字符串

rsplit 

      由右至左
      sep制定分割字符串，默认使用空白字符为分割符
      maxspilt 制定分割的次数，-1表示遍历整个字符串

splitlines（【keepends】

     按照行来切分字符串
     keepends 指的是是否保留行分割符
     行分隔符值得是是否包括\n  、\r\n 、  \r等

元组tuple   

 由（）小括号表示
     一个有序序列
     元组不可变对象
     元组的定义，一个对象加上（1，）逗号，两个（1，2）以上不需要追加逗号
     元组元素的访问
     支持正负索引，可一通过所以访问；tuple（index）：index就是索引  
     元组查询
     index 索引查找，count 返回次数 
     时间复杂度：
     index和count都是O（n）
     len（tuple）：长度查询

元组 只读，所以增改，删除，追加都不可操作

命名元组

    元组名称 namedtuple（类的名称，定义字段：以逗号或空格分割的字符串或者是字段的列表）
   namedtuple在模块的使用方法；
   from collections import namedtuple
   元祖名=namedtuple（‘元祖子类名‘，[   ]）

例子： 

 设置一个元祖名为Student的元祖数据，其中包两个字符串
     Student=namedtuple(‘student‘,‘name age‘)
     开始给组赋值
     设tom=Student（‘tom‘， 20）
     设jarry=Student （ ‘jerry‘ ,  18）
     赋值完成后 输入 tom.name  或者 tom.age 会显示出该成员的名字或者年龄

字符串分割（常用）

partition（sep）
     由左至右，遇到分隔符就把字符串分割成两部分，返回头，分隔符，尾部三元组
如果没有找到分割符，就返回头、2个空元素的三元组
     sep 分割字符串 必须指定
rpartition(sep)
     由右至左，
     由左至右，遇到分隔符就把字符串分割成两部分，返回头，分隔符，尾部三元组
如果没有找到分割符，就返回头、2个空元素的三元组

字符串大小写

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

字符串排版  

center（sep） 默认空格填充
     zfill(sep) 打印宽度，居右，左边用0填充
     title（） 标题的每个单词都大写

字符串修改

   字符串不可变，对字符串的修改会返回一个新的字符串
   replace（old,new[,count]）
   字符串中找到匹配替换为新子串，返回新字符串
   count表示替换几次，默认替换全部

字符串修改

strip（[指定字符]）（常用于去除用户在头尾输入的非法字符）
若没有指定去除什么字符，将会从字符两头去除非法字符
lstrip
     从左开始去除
rstrip
     从右开始去除

字符串朝找

find（sub[，start[,end]]）
     在指定区间，由左至右查找子串sub，找到第一个对应的字符返回索引，没找到返回-1
rfind（sub[，start[,end]]）
      在指定区间，由右至左查找子串sub，找到第一个对应的字符返回索引，没找到返回-1

字符串查找

index（sub[,start[,end]]）
          在指定区间内由左至右查找子串，找到返回索引，没找到报错
rindex（sub[,start[,end]]）
          在指定区间内由右至左查找子串，找到返回索引，没找到报错

字符串查找

     时间复杂度
     index和count都是O(n)
     随着列表数据规模增大，效率下降
     len(string)
     返回字符串的长度

count（sub[,start[,end]]）

     在指定区间由左至右统计子串sub出现的次数

字符串判断->返回布尔值

endswith（suffix[,start[,end]]）
     在指定区间，字符串是否是suffix结尾
stratswith（prefix[,start[,end]]）
     在指定区间，字符串是否是prefix结尾

字符串格式化  

字符串输出用‘’+‘’拼接 非字符串先转后拼接
join拼接只能使用分隔符，且拼接对象是可迭代对象

格式要求

     占位符：使用%和格式字符组成，例如%s、%d等
          s调用str（），r会调用repr（），所有对象都可以被这两个转换
     占位符中还可以插入修饰字符，例如%03d表示打印3个位置，不够前面补0
     format % valus ,格式字符串和被格式的值之间使用%分隔
     valus 只能是一个对象

字符串格式化

format函数格式化字符串语法
     ‘{}{xxx}‘.format(*args,**kwargs)
     args是位置参数，是一个元组
     kwargs是关键字参数，是一个字典
     大括号表示占位符
     {}表示按照顺序匹配位置参数，{n}表示取位置索引为n的值
     {xxx}表示在关键字参数中搜索名称一致的
     {{}}表示打印大括号

位置参数    

“{}：{}".format(‘192.168.1.100‘8888） 按照位置顺序替换前面格式字符串中的占位符

关键字参数或命名参数

 "{server}{1}:{0}".format（8888,‘192.168.1.100‘,server=’web server info：‘，位置参数按照序号匹配   关键字按照名词匹配

      访问元素

       “{0[0]}.{0[1]}.format((‘magedu‘.‘com‘))”

      对象属性访问

   from collections import namedtuple
   Point=namedtuple(‘Point‘,‘x y‘)
   p=Point(4,5)
   "{{{0.x},{0.y}}}".format(p)

对齐

       常用对齐的符号有 <(左对齐)，>(右对齐)，^(默认居中，两端补空格)，*^（默认居中两端补*）

例子

作为一名python开发人员应使用format函数格式化字符串

本周习题：

求100以内的素数并打印出列表，最后显示列表的值

#应用模块
import math

#求一百以内的素数并列表，所以赋值给一个n为100
n=100
#设一个初始列表由2开始
lst=[2]

#利用for循环语句进行第一外循环3~n
for i in range(3,n):
    #利用第二层循环进行lst值的循环
    for j in (lst):
        #如果i的值能整除lst的值；
        if i%j==0:
            #则跳出循环并中断循环；
            break
    #否则
    else:
        #不能整除循环内的数列则被添加到lst中
        lst.append(i)

#最后打印出lst列表中的所有内容
print(lst)

由上得出的结果为

求杨辉三角前6行的值并添加到list列表中，并显示列表中的值

有图可知其规律为：下一列的值，为上一次两次相加的和，1n1   1n+1n+11

    #先设出杨辉三角的lst值[1][1，1]
lst=[[1],[1,1]]

    #取前6的数列为n
n=6
    #依次取出2到n里的值
for i in range(2,n):
    #从list的第三个元素到第n个元素的列表
    pre=lst[i-1]

    #在行首添加一个[1]
    cur=[1]

    #依次取出0到i-1的数值
    for j in range(0,i-1):
        #在cur的列表中追加(j与j+1)的数值
        cur.append(pre[j]+pre[j+1])

        #最后再在上一个命令执行完毕的数值后添加一个1
    cur.append(1)

    #最后将cur列表的值逐加到lst列表当中
    lst.append(cur)

# cur.pop(int(i/2))
#在循环外打印出lst列表的值
print(lst)

得出的结果为

若不设定lst的固定值则可以：

triangle=[]

n=6
for i in range(0,6):
    if i==0:
        triangle=[[1]]

    else:
        pre=triangle[i-1]

        cur=[1]

        for j in range(0,i-1):
            cur.append(pre[j]+pre[j+1])

        cur.append(1)

        triangle.append(cur)

print(triangle)

以上输出结果为

效率型取十万以内的质数并查看其所耗时间

import math
import datetime
n=100000
pn=[]
count=0
start=datetime.datetime.now()
flag=True
for i in range(2,n):
    for j in pn:
        count+=1
        if i%j==0:
            flag=False
            break
        if j>=math.ceil(math.sqrt(i)):
            flag=True
            break
    if flag:

        pn.append(i)
time=(datetime.datetime.now()-start).total_seconds()
print(pn)
print(time)
print(len(pn))
print(count)

结果为：pn值，计算时间，列表数值个数，计算总次数

依次接收用户输入的三个数，并进行排序

方法1：

如何利用sort的方法对list的值进行排序

nums=[]   #设定一个新列表
out=None  #默认输出为空
for i in range(3):     
    nums.append(int(input(‘>>>‘)))


    nums.sort()     #直接用sort对nums列表里的数值进行排序
    print(nums)     #最后打印出nums的数值

得出的结果为升序排序

方法二：

使用max进行排序

使用max进行排序

lst=[1,2,3]  #创建一个列表，列表的值为1，2，3
使用max进行排序

lst=[1,2,3]  #创建一个列表，列表的值为1，2，3
m=[]         #创建一个空列表
for i in range(3): 
    m.append(max(lst))  #将lst的值升序排列追加进m列表中
    lst.remove(max(lst))#依次删除lst中的最大的值
    print(m)            #最后打印出m列表

方法三

使用冒泡法进行排序

如何利用python的排序方法进行对列表的排序

nums_list=[[1,9,8,5,6,7,4,3,2],
           [1,2,3,4,5,6,7,8,9],
           [1,2,3,4,5,6,7,9,8]]
nums=nums_list[0]           # 取出第一个列表的数值
length=len(nums)
flag=False                  #设置一个标记
for i in range(length):
    flag=False              #当输出length的值时，将flag的值更新为假
    for j in range(length-i-1):
        if nums[j]>nums[j+1]:       #利用判断对list中的索引的值进行比较
            tmp=nums[j]             #如果lsit的第一个值比第二个值大，则会将此值利用pop进行排序
            nums[j]=nums[j+1]
            nums[j+1]=tmp
            flag=True               #当上面的程序产生更换时，这里的flag的值就会更新为真了
    if flag==False:                 # 如果flag的值等于假，也就是list的值没有发生变化时为假，会立即跳出循环，并开始下数的循环
        break
# nums.reverse()                    翻转nums列表的值呈倒叙打印
print(nums)

print(nums)的结果为：

冒泡法总结：

 属于交换排序
 两两比较，并交换位置，结果为升序或者倒叙排列
 升序： 从索引0开始，由左至右进行比较，如果该值大于后值将会与后值交换位置。如果后数比前数大，则不交换。并继续向后比较，直到该列表中的值全部依次比较完毕，此时若前面的值为最大的值，应在排序过后会被交换到列表中的最右侧为末尾的值。当进行第二轮比较时，由于上一次比较最右侧为最大值，所以下一轮的比较将会-1次比较次数

降序：

与升序的排序方式相反，其余一样
冒泡法的时间复杂度为 O(n的2次方)

用户输入一个数字

判断时几位数

打印每一位数字及其重复的次数

依次打印出每一位数字，顺序 个 十 百 千 万...位

num=‘‘
#数字输入的简单判断
while True:
    num=input(‘Input a positive number>>>‘).strip().lstrip(‘0‘)
    if num.isdigit():
        break
print("the length of {} is {}.".format(num,len(num)))

#倒叙打印第一种

for i in range(len(num),0,-1):
    print(num[i-1],end=‘ ‘)
print()

#倒叙打印第二种

for i in reversed(num):
    print(i,end=‘ ‘)
print()

#利用负索引打印

for i in range(len(num)):
    print(num[-i-1],end=‘ ‘)
print( )

判断0-9的数字再字符串中出现的数字，每一次迭代都是使用count，都属于O(n)复杂度

counter=[0]*10
for i in range(10): #10*n
    counter[i]= num.count(str(i))
    if counter[i]:
        print("the count of {} is {}".format(i,counter[i]))

print(‘~‘*20)

#迭代字符串本身的字符

counter=[0]*10      #创建数值为10个0的列表
for x in num:       # 依次读取num里的数
    i=int(x)        # 将x的值转为字符串并赋给i
    if counter[i]==0:   #如果counter的第i项为0；
        counter[i]=num.count(x) #那么第i项就等于该数的次数
        print("the count of {} is {}.".format(x,counter[i]))
print(‘~‘*20)

输入5个数字，打印出每个数字的位数，并将这些数字升序打印

#迭代字符串本身的字符

counter=[0]*10
for x in num:
    i = int(x)
    counter[i]+=1   #再counter的第i个索引处补1

for i in range(len(counter)):   #迭代出counter的长度的数
    if counter[i]:              #如果counter不为真，则继续执行下面的命令
        print("the count of {} is {}.".format(i,counter[i]))

#使用sort进行排序

nums=[]     #创建一个空列表
while len(nums)<5:  #  循环
    num=input("please input a number:").strip().lstrip(‘0‘)
    if not num.isdigit():       #如果他不是数字，则不会执行下面的命令
        break               #如果他是数字，则继续下面的命令

    print(‘the length of {} is {}‘.format(num,len(num)))#打印出这个数和他的位度
    nums.append(int(num))   #并将num转为整型并追加到nums中
                #最后打印出nums列表

lst=nums.copy() #将nums列表的值复制给lst中
lst.sort()  #就地排序
print(lst)

#使用冒泡法进行排序

for i in range(len(nums)):
    flag=False
    for j in range(len(nums)-i-1):
        if nums[j]>nums[j+1]:
            tmp=nums[j]
            nums[j]=nums[j+1]
            nums[j+1]=tmp
            flag = True
        if not flag:
            break
print(nums)

以上两种方法都是呈升序打印

最后补上以上关于是否返回none的辨识方法

本文出自 “12575894” 博客，请务必保留此出处http://12585894.blog.51cto.com/12575894/1968221