Python第二课

61581229

　　一、分类

• 　　数值型
  

• 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=num.count(x)
　　
    print("The count of {} is {}.".format(x,countlist))
　　五、输入五位数，打印每个数的位数，将这些数字排序打印，升序
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==0:
　　
        countlist=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))