一、分类
数值型
int： 长×××，无上限，受限于内存大小 float： 整数加小数，支持十进制和科学计数，只有双精度型（不能“全部完全”准确的表示一个小数，3.333333.....，π，近似表达） complex： 实数和虚数组成，实数虚数都是浮点数，3+4.2J bool： int的子类，仅有两个示例：True、False，对应1，0，可以和整数直接运算
类型转换
int（） float（） complex（） bool（），非0为True
二、数字的处理函数
round（），四舍六入五取偶 floor（）地板，向下取整 ceil（）天花板，向上取整 int（）取整 举例
import math print（math.floor(2.5)）
min（）取最小 max（）取最大 pow（x，y）等于x**y pow（8，1/3），开三次方sqrt开方
进制函数，返回字符串
bin（）二进制 oct（）八进制 hex（）十六进制
math.pi π math.e 自然常数
三、类型判断
type（obj），返回类型，而不是自负床
isinstance（obj，class_or_tuple），返回布尔值
a=5，b=“hello”
isinstance（a，int）---->True
isinstance（b，int）---->False
isinstance（a，（int，str））---->True四、列表list
一个队列，一个排列整齐的队列 列表内的个体称为元素，列表由若干元素组成 元素可以是任意对象----int、str、对象、列表
五、列表list定义、初始化
lst=list（） lst1=[ ]，空列表 lst=list（range（5）） 列表不能一开始定义大小，列表可变
六、列表索引访问
索引、也叫下标 正索引：0开始，左到右，下界到上界 负索引：-1开始，右到左，上界到下界 列表通过索引访问：list[0]、list[-1]
七、列表查询
index---->list.index（value，[stop，[stop]]）
lst=[1,2,3,2,4,2,2,2,6] lst.index(2)---->1、lst.index(2,2,7)---->3
lst.count(2)---->5
时间复杂度
O（1）或2，3，4都是常数，固定执行几次，效率最高 index和count都是O（n），要遍历里面的数据 规模越大，效率越差
len（），这是O（1），只会计算长度
八、元素修改
lst[index]=value lst=[1,2,3,4,5] lst[4]=6---->lst[1,2,3,4,6]
九、列表增加、插入元素
append
不执行，返回空，会增加 就地修改 O（1）操作---知道单位长度，直接到达尾部
insert
指定索引index处插入元素----lst.insert(4，8) 就地修改 O（n）操作----挪动，整体后挪 插入时，索引超越上界，尾部追加（这是O（1）），超越下界，头部追加，这是O（n）
lst=[ ]，lst*5---->lst[ ]，空永远是空，lst=[1]的话，结果---lst=[1，1，1，1，1]
lst=[ ],lst1=[ ],----lst+lst1返回新的结果，两个列表不变
extend在后面追加
就地修改 lst.extend(lst1)
remove删除
remove（value）----lst.remove(2),移除列表值2 就地修改，效率O（n）
pop弹出
lst.pop（）弹出最后/（2），弹出2 index，区别于remove的移除value 尾部弹出O（1），中间O（n）
clear（）
清空，考虑垃圾回收问题，jc
十、列表其他操作
reverse（）反转，就地修改
sort（key=None，reverse=False）---sort（）默认排序
对元素进行排序，就地修改，默认升序 reverse为False，不反转，True反转，降序 key和reverse，可以单独使用，但必须带上，key是函数，指定用什么排序，key=int
in/not in
[3,4] in [1,2,[3,4]] for i in [1,1,1,2,3] 返回bool值，可以用if语句
十一、列表复制
lst0=list（range（4））---->hash（id（lst0）） lst1=list（range（4））---->hash（id（lst1）） lst0==lst1---->True，比较数值 lst0 is lst1---->False，比较地址复制
lst2=lst0--->这个连id地址都会产生变化 lst2[2]=10 lst0的index2也会变成10
copy（）
lst0=list(range(4)) lst1=lst0.copy()---->只拷贝内容，不会拷贝其他，新的内存空间，对lst1进行修改，不会更改lst0 lst[index][index]，列表里面的列表查value方法 lst=[1,[1,2,3],10] lst1=lst.copy() lst1[1][1]=20，将[1,2,3]中的2变成20 因为[1,2,3]是个列表，所以拷贝时，直接拷贝了地址，影子拷贝（浅拷贝），所以修改lst1的[1,2,3]时，lst中的[1,2,3]也会改变
深拷贝
copy.deepcopy（） import copy lst0=[1,2,[1,2,3],4] lst5=copy.deepcopy(lst0) lst5[1][1]=20 lst5==lst0---->False深拷贝，将内容完全深入拷贝，不会浅拷贝地址
随机数
random模块 import random randint（a，b）返回[a，b]之间的整数 random.choice([1,2,3,4,5]) random.randrange(1,7,2)---->从1开始，到6结束，2为步长，前闭后开，1，3，5 random.randrange(1)---->一直出现0 random.shuffle（list）打乱、洗牌
十二：元组tuple
小括号表示，不可变 t=（0，1，2）*5 单个表示（1，）逗号必须
十三：元组访问
基本类同列表 不可变，所以没有append这些操作
十四：命名元组
namedtuple student=namedtuple（“s”，“name age”） tom=student（“tom”，22） tom.name
十五：字符串
join，将内部元素用符号隔开 “magedu”.join(“，”) "magedu".join([1,12,222,3]) 字符串相加，获得新的字符串
十六：字符串分割
split（从左至右，默认以空白字符串为分隔符，可以指定，maxsplit最大分割数） “I am a student”.split（“s”，maxsplit=2） rsplit（从右向左） splitlines（【keepends】）按行切割，中括号内可以不加，加则写True，表示保留行分隔符 'ab c\n\nde fg\rkl\r\n'.splitlines(True) partition（head，sep，tail）分成两部分，sep为分割符，必须指定，若分隔符不在字符串内，则分为head，空，空 rpartition从右开始分割，若分隔符不存在，则为空空tail
十七：字符串大小写
upper大写 lower小写 swapcase大小写互换
十八：字符串排版
title（），标题的每个单词都大写 capitalize（）首单词大写
十九：字符串修改：
replace（old，new，【count】） “www.magedu.com”.replace（w，p，2）
二十：字符串修改：
strip（【chars】）去掉字符串中的字符，从两端操作，里面的不操作 strip（）去除两端空白字符 “\n I am a student \n”.strip( )去掉两端空白字符 “\n I am a student \n”.strip( “ Iatne”)去掉空格和latne字符，结果为"m a stud" lstrip\rstrip（从左边或从右边）
二十一：字符串查找
find（sub【，start】【，end】）---->int，返回索引 rfind从右边找 s = "I am very very very sorry" s.find（”very“，5，8）结果为-1，表示没有，因为前”[“后”）“所以要写9 index（sub[,start][,end]）---->int s.index(”very“,5)返回索引 s.rindex（”very“，10）右边找
二十二：字符串查找
count（sub，【，start】【，send】）
二十三：字符串判断：s
endswith（suffix【，start】【，end】）---->bool startswith s = "I am very very very sorry" s.startswith('very') s.endswith('sorry', 5)
二十四：字符串判断
isdigit是否是数字组成 isalnum是否是字母和数字 isalpha是否是字母组成 isupper/islower
二十五：字符串格式化
”{}{}“.format（"x","y"） 位置参数"{}:{}".format('192.168.1.100',888 关键字或命名参数"{server} {1}:{0}".format(8888, '192.168.1.100', server='Web Server Info : ')) 位置参数按照序号匹配，关键字按照名词匹配 访问元素"{0[0]}.{0[1]}".format(('magedu','com')) 对象属性访问 from collections import namedtupl Point = namedtuple('Point','x y') p = Point(4,5) "{{{0.x},{0.y}}}".format(p)----》{{{}}}，两个大括号，表示打印里面的花括号 对齐："{0}*{1}={2:<2}".format(i,j,i*j)for i in range(1,10):
for j in range(1,i+1):
x="{0}*{1}={2:<2}".format(j,i,i*j)
print(x,end="")
print(){:^30}'.format('centered')' {:*^30}'.format('centered
二十六：切片
“www.magedu.com”[4:10],取magedu，10不取，可加步长，跳跃取值
作业：
一、求质数：
方法一：
primelst=[]
for i in range(2,10000):
for j in primelst:
if i%j==0:
break
else:
primelst.append(i)
print(primelst)方法二：
import datetime
start=datetime.datetime.now()
import math
primelst=[]
flag=False
for i in range(2,100000):
for j in primelst:
if i%j==0:
flag=True
break
if j>=math.ceil(i**0.5):
flag=False
break
if not flag:
primelst.append(i)
print(primelst)
delta = (datetime.datetime.now()-start).total_seconds()
print(delta)二、杨辉三角
方法一：
lst=`1`
for i in range(1,6):
cur=[1]
pre=lst[i-1]
for j in range(0,i-1):
cur.append(pre[j]+pre[j+1])
cur.append(1)
lst.append(cur)
print(lst)方法二：
triangele=[]
n =6
for i in range(n):
pre=[1]
for j in range(i):
if j==i-1:
pre.append(1)
else:
pre.append(0)
triangele.append(pre)
for k in range(1,i//2+1):
cur=triangele[i-1][k-1]+triangele[i-1][k]
pre[k]=cur
if k!=i-k:
pre[-k-1]=cur
print(triangele)三、冒泡法：
题一：输入三个数，升序排列
numlist=[]
for i in range(3):
numlist.append(int(input("{}:".format(i))))
for i in range(3):
for j in range(3-i-1):
if numlist[j]>numlist[j+1]:
tmp=numlist[j]
numlist[j]=numlist[j+1]
numlist[j+1]=tmp
print(numlist)题二：长排序
numlist=[[1,9,8,5,6,7,4,3,2],[1,2,3,4,5,6,7,8,9],[1,9,2,3,4,5,6,7,8]]
num=numlist[0]
length=len(num)
for i in range(length):
for j in range(length-i-1):
if num[j]>num[j+1]:
tmp=num[j]
num[j]=num[j+1]
num[j+1]=tmp
print(num)题二高效法
numlist=[[1,9,8,5,6,7,4,3,2],[1,2,3,4,5,6,7,8,9],[1,9,2,3,4,5,6,7,8]]
num=numlist[0]
length=len(num)
for i in range(length):
flag=False
for j in range(length-i-1):
if num[j]>num[j+1]:
tmp=num[j]
num[j]=num[j+1]
num[j+1]=tmp
flag=True
if not flag:
break
print(num)四：用户输入一个数字：1、判断是几位数 2、打印每一位数字及重复次数 3、个十百千万的打印出来
while True:
num=input("print input a num:").strip("0")
if num.isdigit():
break
else:
print("Wrong number")
print("The length of {} is {}".format(num,len(num)))
for i in range(len(num),0,-1):
print(num[i-1],end=" ")
print()
countlist=[0]*10
for x in num:
i=int(x)
countlist[i]=num.count(x)
print("The count of {} is {}.".format(x,countlist[i]))五、输入五位数，打印每个数的位数，将这些数字排序打印，升序
numlist=[]
while len(numlist)<5:
num=input("please input a number:").strip().lstrip("0")
if not num.isdigit():
continue
numlist.append(int(num))
print(numlist)
for x in numlist:
print("The {} of length is {}".format(x,len(str(x))))
numlist.sort()
print(numlist)六、随机产生十个数字，要求，每个数字取值范围1-20，统计重复的数字有几个，分别是什么，不重复的，分别是什么，有几个
反求索引
import random
numlist=[]
countlist=[0]*21
while len(numlist)<10:
numlist.append(random.randint(1,20))
print(numlist)
for i in numlist:
if countlist[i]==0:
countlist[i]=numlist.count(i)
# print(countlist)
for j in range(21):
if countlist[j]!=0:
print("The count of {} is {}.".format(j,countlist[j]))使用新建列表方法：
import random
num =[]
for i in range(10):
num.append(random.randint(1,20))
print(num)
counter = [0]*21
list1 = []
list2 = []
number = 0
number1 = 0
for x in num:
if counter[x] == 0:
counter[x] = num.count(x)
if counter[x] > 1:
number += 1
list1.append(x)
else:
number1 += 1
list2.append(x)
print('{} {}'.format(number,list1))
print('{} {}'.format(number1,list2))