Python复习(拾遗)

一

摩尔定律

　　单位面积集成电路可容纳晶体管数量每两年翻倍：CPU ，GUP， 内存， 硬盘 的价格都与此有关

　　C1972

　　python1990

计算机 两种方法编译(类似翻译)和解释(类似同声传译)     把源代码(人)编译为目标代码(机器)

　　依据执行方式不同

　　　　静态语言C/C++ Java 编译执行 快

　　　　脚本语言 python 慢
输入 输出 处理
　　　　　　　　处理：利用算法



　　

 

eval(字符串或者字符串变量)
错误：eval("hello")
因为hello不是字符串

二

turtle库

import turtle
turtle.setup(1000,1000,0,0)
turtle.goto(200,200)
turtle.goto(200,-200)
turtle.goto(0,0)

turtle.goto(-200,200)
turtle.goto(-200,-200)

turtle.goto(-100,-100)



turtle.circle(100,360)
turtle.bk(200)
turtle.fd(400)

turtle.seth(90)
turtle.fd(300)
turtle.seth(180)
turtle.fd(300)

turtle.penup()
turtle.fd(-600)
turtle.pendown()

turtle.pensize(10)
turtle.pencolor("purple")
turtle.fd(300)

for i in range(6):
    turtle.fd(100)
    turtle.left(60)
    
turtle.penup()
turtle.fd(300)
turtle.pendown()

for i in range(9):
    turtle.fd(100)
    turtle.left(40)

 

import<库名>as<库别名>

三

Python整数
    pow()
    整数无限制
    四种进制 12 0B12 0O12 0X12 还有BOX小数也可以
浮点数:与数学中实数一致
    取值范围和精度基本无限制
    有取值范围 精度10e-16
    浮点数运算存在不确定尾数，不是bug,发生在16位左右
    0.1+0.2==0.3
    False
    round(0.1+0.2,16)==0.3 True
    round(0.1+0.2,17)==0.3 False
    科学计数法 4.3e-1==0.43
复数 与数学中复数观念一致 3+4j
运算符 略
运算函数
    abs
    divmod(x,y)
    pow()
    round()
    max() min() int() float() complex()
字符串
    索引和切片 "12345"[-1]    "12345"[:-1] "1234567890"[3:8:2]
    字符串处理函数
        len str hex oct chr ord 
    方法 指某一种函数，.()该函数b和a有关
        字符串的方法
        str.lower() upper  split count replace center(20,"++")
        strip join 
    字符串的格式化
        掌握format方法
            "{1:*>30},{0:=^20}".format("111","222") 可以作用于字符串和数字
            "{0:,.3f}".format(56332.334567)   ,.2f只能用于数字
            "{2:*>30,.2f}  {1:-^20}   {0:+<10}".format("123","456",789000.9999)     

 

 

程序的分支结构
    单
        if True:
            执行
    
    双  if True：
            执行A
        else:
            执行B
    多  if elif...else
    
    异常处理
    try except

 

 

程序的循环结构
    遍历循环
        for i in <遍历结构>: range遍历 字符串遍历 列表遍历 文件遍历etc..
    无限循环
        while 只要满足条件就不停止:
    循环控制的保留字
        break 跳出执行循环之后的语句
        continue 跳过本次循环，执行后续循环
    循环和else
        如果循环没有被break退出，也就是可以执行后面的else.
        一旦被break跳出了整个循环，else也便不能执行了。
        例如：
            for i in "dsfgfdfd":
                if i=="g":
                    break
                print(i)
            else:
                print("正常")
  =======================================                                      
            for i in "dsfgfdfd":
                if i=="g":
                    continue
                print(i)
            else:
                print("正常")
                

 

函数的定义
    函数定义指定的参数是一种占位符
    调用是函数执行的方式，调用函数输入实际参数，获得返回值
    函数可以有参数，也可以没有参数，但是必须保留括号
    函数定义可以指定可选参数例如 def fact(n,m=1)
    函数定义可以设计可变数量参数即不确定参数总数量 def fact(<参数>,*b)
    函数调用时，参数可以按照位置和名称方式传递 def fact(2,3) ; def fact(n=2,m=3)
    函数也可以任意个(也可以是0个)返回值
    局部变量和全局变量
        局部变量和全局变量是不同变量 使用global函数可以在函数内部使用全局变量
        局部变量为组合数据类型且未创建，等于全局变量。
            def func(a):
                ls.append(a)
                return
            func("c")
            print(ls)
            
            ['F', 'f', 'c']
        lambda函数
            lambda函数是一种匿名函数即没有名字
            使用lambda保留字定义，函数名是返回结果
            lambda <参数>:<表达式>
                f=lambda x,y:x+y
                f=lambda:"lambda函数"
代码复用和函数递归
    代码复用与模块化设计
        函数和对象(属性和方法)是代码复用的主要方式
        模块化设计拆分为组合程序，子程序，子程序之间关系，模块内部紧耦合，外部松耦合
    函数递归的理解:函数定义中调用自身的方式，类似于数学归纳法
    函数递归的调用过程
    函数递归的实例解析
        链条和基例
        例子
            字符串翻转
                def c(n):
                    if n=="":
                        return n
                    else:
                        return n[-1]+c(n[:-1])
            斐波那契数列
                def f(a):
                    if a==1:
                        return 1
                    elif a==2:
                        return 1
                    else :
                        return f(a-1)+f(a-2)
            汉诺塔作为练习                  


            

 

 

集合 
   集合类型定义
        和数学中集合概念一致
        无序，元素唯一，类型不可更改，不可以是可变数据类型
        {}或set()
    集合操作符
        |-&^><==
    集合处理方法
        add discard remove clear pop随机删除一个 copy len set x in s
        
    集合类型应用场景
        包含关系比较
        数据去重，集合类型所有元素无重复
序列
    序列类型和定义
        序列是有先后关系的一组元素，元素类型可以不同，元素之间由序号引导，通过下标访问
        序列包含 字符串 元组 列表
    序列通用操作符
        x in s
        s+t
        s*n
        s[i]
        s[i:j:k]
        s[::-1]倒序
    序列通用方法和函数
        len min max s.index(x,i,j) s.count(x)
    元组(具备序列基础功能)
        元组一旦创建不可更改     (集合也不可更改)
        使用()或者turtle()创建   (有点像集合{}和set())
        可以使用，也可以不使用小括号
        元组继承了序列类型全部通用操作符，但是因为元组创建后不可更改，因此没有特殊操作。
    列表(在序列基础上增加了更多功能)
        创建后可以被随意更改
        使用list()或[]创建,元素之间用逗号分隔
        列表各元素类型可以不同，无长度限制。
        列表类型操作函数和方法
            list[i]=x替换
            list[i:j:k]=x
            del ls[i]
            del[i:j:k]
            ls+=lt
            ls*=n
            append clear copy ls.insert(i,x) ls.pop(i)这个默认删除最后一个，与集合随机删除不同
            集合因为无序，所以随机删除。remove reverse 
    序列类型应用场景
        元组用于数据不变的，数据保护
        总的来说,表示一组有序数据，经常用于元素遍历。for i in <列表或者字符串>
字典
    定义
        字典是键值对的集合，键值对之间无序。
        采用{}和dict()创建  (和集合有点像啊)
        创建 c= {1: 1, 2: 2}  c=dict(1=1,2=2)报错，dict不可以
            a=dict(李白="静夜思", 毛敏感词汇="实践论")
            a={"李白":"静夜思","毛敏感词汇":"实践论"}
        提取
            a[李白]           
    函数和方法
        del d[k]
        k in d
        d.keys()
        d.values()
        d.items() 返回所有键值对对应信息
        d.get(k,<>) 假如k存在，返回相应值，不在返回<>
        d.pop(k,<>)
        d.popitem() 随机删除一个键值对，以元组形式返回
        d.clear()删除所有键值对
        len() 返回键值对个数
    应用场景
        表达映射
        元素遍历
    

 

 

转载于:https://www.cnblogs.com/xinqidian/p/10188219.html