zoukankan      html  css  js  c++  java
  • 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 
        方法 指某一种函数,<a>.<b>()该函数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() 返回键值对个数
        应用场景
            表达映射
            元素遍历
        

  • 相关阅读:
    python------面向对象介绍
    python------模块定义、导入、优化 ------->re模块
    python------模块定义、导入、优化 ------->hashlib模块
    Java过滤器Filter使用详解
    EL表达式、 jstl标签
    jsp 自定义标签中的Function函数
    JSP 自定义标签
    javax.el.PropertyNotFoundException: Property 'name' not found on type java.lang.String
    JSP 中EL表达式用法详解
    JavaWEB
  • 原文地址:https://www.cnblogs.com/xinqidian/p/10188219.html
Copyright © 2011-2022 走看看